Java desde 0

Tomado de:
http://mmc.geofisica.unam.mx/cursos/mcst-2007-II/J
ava/Java%20desde%20Cero.pdf
¿Qué es java ?

 Java es un lenguaje originalmente desarrollado por un

grupo de ingenieros de Sun, utilizado por Netscape,
posteriormente como base para JavaScript. Si bien su
uso se destaca en la Web, sirve para crear todo tipo de
aplicaciones (locales, intranet o internet).
Java es un lenguaje de objetos y independiente de la
plataforma y tiene algunas características notables como lo
son:
 Es robusto
 Gestiona la memoria automáticamente
 No permite el uso de técnicas de
programación inadecuadas
multithreading
 Cliente-servidor
 Mecanismos de seguridad incorporados
herramientas de documentación
incorporadas
Lenguaje Orientado a objetos

 Al contrario de otros lenguajes como C++, no es un

lenguaje modificado para poder trabajar con objetos
sino que es un lenguaje creado para trabajar con
objetos desde cero. De hecho, TODO lo que hay en Java
son objetos.
¿Qué es un objeto?

 Es una pieza de software que cumple con ciertas

características:
Ejemplo
Encapsulamiento o Herencia
 Independiente de la
plataforma

Java se puede correr desde cualquier ordenador, las únicas

características que exige es que el S.O sea multitarea y
multiusuario Como puede ser:

Windows, Linux, Unix ,OS/2

 Algunas características

 Java no permite el manejo directo del hardware ni de la

memoria (inclusive no permite modificar valores de punteros, por
ejemplo); de modo que se puede decir que es virtualmente
imposible colgar un programa Java.

 El intérprete siempre tiene el control.

 Inclusive el compilador es suficientemente inteligente como para

no permitir un montón de cosas que podrían
 traer problemas, como usar variables sin inicializarlas, modificar
valores de punteros directamente, acceder a
 métodos o variables en forma incorrecta, utilizar herencia
múltiple, etc.
 Además, Java implementa mecanismos de seguridad
que limitan el acceso a recursos de las máquinas donde
se ejecuta, especialmente en el caso de los Applets
(que son aplicaciones que se cargan desde un servidor y
se ejecutan en el cliente)
Las clases en Java

 en Java hay un montón de clases ya definidas y

utilizables. Éstas vienen en las bibliotecas estándar:
JAVA.LANG
clases esenciales, números, strings, objetos, compilador,
runtime, seguridad y threads
(es el único paquete que se incluye automáticamente en
todo programa Java)
 java.io
clases que manejan entradas y salidas

java.util
clases útiles, como estructuras genéricas, manejo de
fecha, hora y strings, número aleatorios, etc.

java.net
clases para soportar redes: URL, TCP, UDP, IP, etc.
 java.awt
clases para manejo de interface gráfica, ventanas, etc.

java.awt.image
clases para manejo de imágenes

java.awt.peer
clases que conectan la interface gráfica a implementaciones
dependientes de la plataforma (motif, Windows)
 java.applet
clases para la creación de applets y recursos para
reproducción de audio. Para que se den una idea, los
números enteros, por ejemplo, son "instancias" de una clase
no redefinible, integer, que desciende de la clase Number.
 Estructura de una
/Le damos un nombre "MiClase" a la clase
clase
public class MiClase
{
//Atributos de la clase
private String atributo1;
private int atributo 2;
private float atributo 3;
//Constructor con el mismo nombre de la clase
public MiClase(){}
//Métodos de la clase
public void metodo1()
{
//Método vacio
} public String metodo2()
{
return "metodo2";
}
}
 EJEMPLO
 package misClases; //Se le declara un paquete
 public class Animal
 {
 private String raza;
 private String nombre;
 private int edad;
 public Animal(String nuevoNombre)
 {
 nombre = nuevoNombre; //Se le da un nombre al animal
 }
 //Método para obtener la edad del animal
 public int getEdad()
 {
 return edad;
 }
 //Método para establecer la edad del animal
 public void setEdad(int nuevaEdad)
 {
 edad = nuevaEdad;
 }
 //Método para obtener el nombre del animal
 public String getNombre()
 {
 return nombre;
 }
Declaración de la clase

 La clase se declara mediante la línea public class. En el

caso más general, la declaración de una clase puede
contener los siguientes elementos:
Public, final o abstract

(public)
 Definir una clase como pública (public) significa que
puede ser usada por cualquier clase en cualquier
paquete. Si no lo es, solamente puede ser utilizada por
clases del mismo paquete (más sobre paquetes luego;
básicamente, se trata de un grupo de clases e interfaces
relacionadas, como los paquetes de biblioteca incluidos
con Java).
Public, final o abstract

(final)
 Una clase final (final) es aquella que no puede tener
clases que la hereden. Esto se utiliza básicamente por
razones de seguridad (para que una clase no pueda ser
reemplazada por otra que la herede), o por diseño de la
aplicación.
Public, final o abstract
(abstract)
Una clase abstracta (abstract) es una clase que puede
tener herederas, pero no puede ser instanciada. Es,
literalmente, abstracta (como la clase Number definida en
java.lang). ¿Para qué sirve? Para modelar conceptos. Por
ejemplo, la clase Number es una clase abstracta que
representa cualquier tipo de números (y sus métodos no
están implementados: son abstractos); las clases
descendientes de ésta, como Integer o Float, sí
implementan los métodos de la madre Number, y se
pueden instanciar.

Por lo dicho, una clase no puede ser final

y abstract a la vez (ya que la clase
abstract requiere descendientes…)
 Extends

 La instrucción extends indica de qué clase

desciende la nuestra. Si se omite, Java
asume que desciende de la superclase
Object. Cuando una clase desciende de
otra, esto significa que hereda sus atributos
y sus métodos (es decir que, a menos que
los redefinamos, sus métodos son los
mismos que los de la clase madre y pueden
utilizarse en forma transparente, a menos
que sean privados en la clase madre o, para
subclases de otros paquetes, protegidos o
propios del paquete).
Implements

 Una interface (interface) es una clase que declara sus

métodos pero no los implementa; cuando una clase
implementa (implements) una o más interfaces, debe
contener la implementación de todos los métodos (con
las mismas listas de parámetros) de dichas interfaces.
Esto sirve para dar un ascendiente común a varias
clases, obligándolas a implementar los mismos métodos
y, por lo tanto, a comportarse de forma similar en
cuanto a su interface con otras clases y subclases.
Interface

 Una interface (interface), como se dijo, es una clase

que no implementa sus métodos sino que deja a cargo
la implementación a otras clases. Las interfaces
pueden, así mismo, descender de otras interfaces pero
no de otras clases
El cuerpo de la clase

 El cuerpo de la clase, encerrado entre { y }, es la lista

de atributos (variables) y métodos (funciones) que
constituyen la clase.
 Declaración de atributos
En Java no hay variables globales; todas las
variables se declaran dentro del cuerpo de la clase
o dentro de un método.

Las variables declaradas dentro de un método son

locales al método

las variables declaradas en el cuerpo de la clase

se dice que son miembros de la clase y son
accesibles por todos los métodos de la clase.
 se dice que son atributos de clase si se usa la palabra clave
static: en ese caso la variable es única para todas las
instancias (objetos) de la clase (ocupa un único lugar en
memoria). Si no se usa static, el sistema crea un lugar nuevo
para esa variable con cada instancia (o sea que es
independiente para cada objeto).
 La declaración sigue siempre el mismo esquema:

[private |protected|public] [static] [final] [transient]

[volatile] Tipo NombreVariable [= Valor];
 Private, protected public
packge
 De acuerdo a la forma en que se especifica
un atributo, objetos de otras clases tienen
distintas posibilidades de accederlos:
Static y final

Como ya se vio, static sirve para definir un atributo como

de clase, o sea único para todos los objetos de la clase.

En cuanto a final, como en las clases, determina que un

atributo no pueda ser sobre escrito o redefinido. no se
trata de una variable, sino de una constante.
 Los tipos de variables en Java
Los tipos de variables disponibles son básicamente 3:
 • tipos básicos (no son objetos)
 • arreglos (arrays)
 • clases e interfaces
 Con lo que vemos que cada vez que creamos una clase o
interface estamos definiendo un nuevo tipo.
Los tipos de datos básicos
para variables
 Métodos
Los métodos, como las clases, tienen una declaración y un
cuerpo

[private |protected|public] [static] [abstract]

[final] [native ] [synchronized]
TipoDevuelto NombreMétodo
( [tipo1 nombre1[, tipo2 nombre2 ]…] )
[throws excepción1 [,excepción2]… ]
El cuerpo de los métodos
Dentro de los métodos pueden incluirse:

• Declaración de variables locales

• Asignaciones a variables
• Operaciones matemáticas
• Llamados a otros métodos:
• Estructuras de control
• Excepciones (try, catch,etc)
Declaración de variables
locales
Las variables locales se declaran igual que los atributos de
la clase:
Tipo NombreVariable [= Valor];
Ejemplo
int suma; int suma = 0;
float precio; float precio = 12.3;
Las variables locales se declaran igual que los atributos de la clase:
Tipo NombreVariable [= Valor];
Ej: int suma;
float precio;
Contador laCuenta;
Sólo que aquí no se declaran private, public, etc., sino que las variables definidas dentro del método sólo son
accesibles por él.
Las variables pueden inicializarse al crearse:
Ej: int suma = 0;
float precio = 12.3;
Contador laCuenta = new Contador ( );
Podemos declarar las variables en Java de la siguiente
manera

TIPO DE DATO: tipo de datos que se pueden almacenar en

esta variable.
NOMBRE_VARIABLE: nombre dado a la variable.
VALOR: es el valor inicial almacenado en la variable.

Por ejemplo: el tipo de dato String se puede especificar para

permitir que una variable llamada “mensaje” contenga texto con
esta declaración:
String mensaje;

Los nombres de variables también deben evitar las palabras clave

de Java, ya que tienen un significado especial en el lenguaje
Java.
Asignaciones a variables
Se asigna un valor a una variable mediante el signo =:
Variable = Constante | Expresión ;
Ej: suma = suma + 1;
precio = 1.05 * precio;
laCuenta.cnt = 0;
 Para poder hacer uso de una variable declarada en un
programa, previamente hay que asignarle un valor.
EJEMPLO Habiéndose declarado la siguiente variable para
almacenar la edad de una persona, es decir, un número entero:
int edad;
 Si en la variable edad se quiere guardar, por ejemplo, el
número 21, en Java esto se puede hacer escribiendo:
fíjese que, al igual que en la declaración, también hay que
escribir un punto y coma (;) al final de esta instrucción.

El símbolo (=) representa al operador de asignación de Java que,

en este caso, asigna –almacena– el valor 21 en el espacio de
memoria representado por la variable edad: Edad= 21;
 Operaciones matemáticas
Hay varios tipos de operadores:
Unarios: + - ++ -- ~ !.
Se colocan antes (o en algunos casos después) de la constante o expresión.
Por ejemplo: -cnt; // cambia de signo; por ejemplo si cnt es 12 el resultado es -12; cnt no
cambia.
++cnt; // equivale a cnt += 1;
cnt++; // equivale a cnt +=1; veremos la diferencia al hablar de estructuras de control
--cnt; // equivale a cnt -= 1;
cnt--; // equivale a cnt -= 1;
Binarios: + - * / %
Van entre dos constantes o expresiones o combinación de ambas.

Por ejemplo: cnt + 2; // debuelve la suma de ambos.

promedio + ( valor / 2); // como se ve, se pueden usar paréntesis.
horas / hombres; // división.
acumulado % 3; // resto de la división entera entre ambos.
Nota: + sirve también para concatenar cadenas de caracteres; hablaremos de String y
StringBuffer pronto.
Cuando se mezclan Strings y valores numéricos, éstos se convierten automáticamente a
cadenas:
"La frase tiene " + cant + " letras"
se convierte en: "La frase tiene 17 letras" // suponiendo que cant = 17
Cómo llamar a un método en Java
 Pasos

1
Un método es el equivalente a una función en lenguajes como C que ayuda a
reutilizar el código. Un grupo de sentencias es un método y un método puede
ser invocado por cualquier otra sentencia. Cuando se llama a un método en
java, todas las sentencias dentro del método serán ejecutadas. Por ejemplo,
mira este método. "public static void methodExample() {}". No lleva código,
pero existe tres palabras clave antes del nombre del método. Estos
son: public, static, y void.
2
La palabra public antes del método significa que el método puede ser
llamado desde cualquier parte, lo que incluye otras clases, e inclusive,
diferentes archivos mientras la clase sea importada. Hay otras palabras que
pueden reemplazar public. Estas son, protected y private. Si un método
es protected, entonces solo podrá ser utilizado en su clase y subclases (o
sea, las clases que se creen a partir de esta). Si un método es private,
entonces solo puede ser utilizado dentro de la clase. La última palabra no
existe realmente y se pone por defecto cuando no utilizas ninguna de las
otras dos y evitará que el método sea llamado de otro lugar que no sea su
clase.
3
La segunda palabra clave es static que significa que el método
pertenece a una clase y no a un instancia de la clase(objeto). Los
métodos estáticos deben ser llamados utilizando el nombre de la clase:
"ExampleClass.methodExample()". Sin embargo, si la palabra static no
se encuentra allí, entonces el método solo puede ser invocado a través
de un objeto. Por ejemplo, si la clase tenía por
nombre ExampleObject y tenía un constructor(los que hacen objetos),
entonces podemos hacer un nuevo objeto escribiendo ExampleObject
obj = new ExampleObject();, y llamar al método
con"obj.methodExample();".
4
La última palabra en el método es void. La palabra void significa que el método no
devuelve nada(o sea que no devuelve nada cuando corre el método). Si quieres que un
método devuelva algo, reemplaza la palabra void con un tipo de información del objeto
que deseas que retorne. Luego, adiciona return más un objeto del tipo buscado al final
del código en el método.
5
Cuando llames a un método que retorna algo, puedes usar lo que devuelve. Por
ejemplo, si un método someMethod() retorna un entero, entonces puedes
asignar este valor a lo que retorna como en el siguiente ejemplo: "int a =
someMethod();"
6
Algunos métodos requieren un parámetro. El método que requiere un parámetro de tipo entero
se vería así: someMethod(int a) Cuando uses un método de esta manera, escribe el método y

luego el entero entre paréntesis: someMethod(5) o someMethod(n) si n es un entero .

7
Los métodos pueden tener múltiples parámetros que van separados por comas. Si el
método someMethod requiere dos parámetros, int a y Object obj, se vería como así:
"someMethod(int a, Object obj)". Para usar este nuevo método, usa el nombre del
método seguido de un entero y un objeto entre paréntesis: someMethod(4,
thing) donde thing es un Object.
CONSEJOS

 Cuando llames a un método que devuelve un valor,

puedes llamar a otro método basado en lo que
devuelve otro método. Por ejemplo, supongamos
que tenemos un método getObject() que devuelve
un objeto. En la claseObject, hay un método no
estático llamado toString que devuelve el Object en
la forma de una cadena (String). Así que, si lo que
quieres obtener es una cadena (String) del objeto
(Object) que utilice getObject() para retornarlo,
escribe ".String str = getObject().toString();".
 Ten cuidado con las clases y métodos abstractos. Si
un método es abstracto, no puede ser utilizado a
menos que sea implementado por otra clase. Es se
debe a que el método no tienen ningún código en
primer lugar. Las clases abstractas son utilizadas
como una especie de marco de referencia o trabajo.
 ESTRUCTURAS SECUENCIAL

 este tipo de estructura la ejecutamos en cada uno de nuestros

programas de manera predeterminada, porque si analizamos
nuestros programas en Java siempre siguen una secuencia, por lo
cual estas instrucciones se van ejecutando una seguida de otra en
el orden que aparece en nuestro programa.
ESTRUCTURA DE CONTROL CONDICIONAL O
SELECTIVA EN JAVA

 Estas estructuras de control condicional son usadas para hacer

una decisión mediante comparaciones dependiendo del
planteamiento del problema.

 En Java no da la posibilidad de trabajar con muchas estructuras

de control selectivas, estas son: if, else, switch, su uso es
relativamente sencillo.
 IF…[ELSE]

 Nos da la posibilidad de crear estructuras condicionales para que se ejecute

una instrucción en caso que cumpla la condición y otra en caso que no cumpla.

 nos permiten tomar cierta decisión al interior de nuestro algoritmo, es decir,

nos permiten determinar que acciones tomar dada o no cierta condición
 Ejercicios
 1. La calificación final de un estudiante de Informática se
calcula con base a las calificaciones de cuatro aspectos de
su rendimiento académico: participación, primer examen
parcial, segundo examen parcial y examen final. Sabiendo
que las calificaciones anteriores entran a la calificación
final con ponderaciones del 10%, 25%, 25% y 40%, Hacer
un programa que calcule e imprima la calificación final
obtenida por un estudiante.
 2. Guillermo tiene N pesos . Luis tiene la mitad de lo que
posee Guillermo. Juan tiene la mitad de lo que poseen
Luis y Guillermo juntos. Hacer un programa que calcule e
imprima la cantidad de dinero que tienen entre los tres.
 3. Crear un algoritmo donde el usurario digite un numero
y posteriormente analizar e imprimir si es positivo o
negativo y si es par o impar
 4. Pedir números al usuario y cuando el usuario meta un -1
se terminará el programa.
 Al terminar, mostrará lo siguiente:
 – mayor numero introducido
 – menor numero introducido
 – suma de todos los números
 – suma de los números positivos
 – suma de los números negativos
 – media de la suma de todos los numeros
 El número -1 no contara como número.
 5. Dados dos puntos en el plano cartesiano por los cuales
pasa una recta, indica si dicha recta es paralela al eje X
(horizontal), paralela al eje Y (vertical) o no paralela a los
ejes. X1, Y1, X2, Y2, siendo los dos primeros las coordenadas
del primer punto, y los últimos las coordenadas del segundo
punto .Si es paralela debe imprimir “Recta paralela al eje
X”, “Recta paralela al eje Y” y si no es “Recta no paralela a
ningún eje”
 SWITCH…CASE…BRAKE…DEFAULT
Permite ejecutar una serie de operaciones para el caso de que una variable tenga un valor entero dado.

 Funcionamiento de la instrucción switch:

 Primero se evalúa la expresión y salta
al case cuya constante coincida con el valor de
la expresión.
 Se ejecutan las instrucciones que siguen
al case seleccionado hasta que se encuentra
un break o hasta el final del switch.
El break produce un salto a la siguiente
instrucción a continuación del switch.
 Si ninguno de estos casos se cumple se ejecuta
el bloque default (si existe). No es obligatorio
que exista un bloque default y no tiene porqué
ponerse siempre al final, aunque es lo habitual.
 WHILE DO…WHILE

 permite repetir la ejecución de do sentencia while (condición

un grupo de instrucciones ); sentencia. Una sentencia
mientras se cumpla una que se ejecuta al menos una
condición (es decir, mientras la vez y es re ejecutada cada
condición tenga el valor vez que la condición se
True). ... si el resultado es evalúa a verdadera. Para
ejecutar múltiples sentencias
False, el cuerpo del bucle no se
dentro de un bucle, utilice la
ejecuta y continúa la ejecución sentencia block ( { ... } )
del resto del programa.

La traducción de while en español es mientras. Por lo

tanto, la sentencia while se puede entender como
"mientras se cumpla la condición, ejecuta el siguiente
bloque de código entre llaves.
 FOR

También para ejecutar en forma

repetida una serie de instrucciones  ciclos for (o ciclos para) son una estructuras
de control cíclica, nos permiten ejecutar una o
varias líneas de código de forma iterativa (o
repetitiva), pero teniendo cierto control y
conocimiento sobre las iteraciones.
 BREAK Y CONTINUE

se utilizan en Java para detener completamente

un bucle (break) o detener únicamente la
iteración actual y saltar a la siguiente (continue). 

 diferencia entre ambos

break, detiene la ejecución del bucle y continue, detiene la iteración actual y

salta a la primera línea del programa pasa a la siguiente iteración del bucle
tras el bucle sin salir de él (a menos, que el propio
bucle haya llegado al límite de sus
iteraciones).
La sentencia continue provoca que únicamente la
iteración actual del bucle más interno detenga su
ejecución y que comience inmediatamente la
siguiente iteración si el bucle todavía no ha
terminado.

la sentencia break provoca que el programa

detenga la ejecución del bucle más interno
y continúe la ejecución desde la primera
línea de código que se encuentre tras el
bucle.
 SYNCHRONIZED
(PARA VER JUNTO CON LOS THREADS)

se usa para indicar que ciertas partes del código, (habitualmente, una
función miembro) están sincronizadas, es decir, que solamente un
subproceso puede acceder a dicho método a la vez.

Las siguientes porciones de código son ejemplos de

uso del modificador synchronized
 THROW

se utiliza para lanzar explícitamente una excepción. En primer lugar se debe obtener un
descriptor de un objeto Throwable, bien mediante un parámetro en una cláusula catch o, se
puede crear utilizando el operador new.
 try

Try en inglés es el verbo intentar, así

que todo el código que vaya dentro de
esta sentencia será el código sobre el
que se intentará capturar el error si se
produce y una vez capturado hacer algo
con él. Lo ideal es que no ocurra un
error, pero en caso de que ocurra un
bloque try nos permite estar
preparados para capturarlo y tratarlo. 
 CATCH

En este bloque definimos el conjunto de

instrucciones necesarias o de tratamiento del
problema capturado con el bloque try anterior. Es
decir, cuando se produce un error o excepción en
el código que se encuentra dentro de un bloque
try, pasamos directamente a ejecutar el conjunto
de sentencias que tengamos en el bloque catch.
FINALLY

el bloque finalmente
siempre se ejecuta,
se produzca o no una
excepción en el
bloque try

 es un bloque donde podremos definir un

conjunto de instrucciones necesarias tanto si se
produce error o excepción como si no y que por
tanto se ejecuta siempre.
Definición de número complejo

 Un número complejo, es una entidad matemática

que viene dada por un par de números reales, el
primero x se denomina la parte real y al segundo y
la parte imaginaria. Los números complejos se
representa por un par de números entre paréntesis
(x, y), como los puntos del plano, o bien, en la
forma usual de x+yi, i se denomina la unidad
imaginaria, la raíz cuadrada de menos uno. La clase
Complejo constará de dos miembros dato, la parte
real real, y la parte imaginaria imag, ambos del
tipo predefinido double.
La clase Complejo

Escribe una clase Complejo que modele el comportamiento de los números

complejos.
Un número complejo, es una entidad matemática que viene dada por un par de
números reales, el primero a se denomina la parte real y al segundo b la parte
imaginaria.
Se representa escribiendo las dos partes del número entre paréntesis (a, b) o
también de la forma a + bi.
La i se denomina unidad imaginaria, representa la raíz cuadrada de -1.
La clase Complejo tendrá dos datos privados de tipo double: parte real y parte
imaginaria.
La clase Complejo contendrá un constructor por defecto que inicializará a 0 los
atributos y un constructor con dos parámetros correspondientes a los valores de la
parte real e imaginaria a asignar al nuevo objeto.
Contendrá, además de los setters y getters, los siguientes métodos:
La clase contendrá además un método toString para mostrar el número
complejo de la siguiente forma: (parte real, parte imaginaria) y un método
equals que compruebe si dos números complejos son iguales o no.
Una vez creada la clase, escribe un programa para probar la clase. Un ejemplo
de main podría ser este:

Si la clase Complejo
está bien diseñada,
este programa debe
mostrar el siguiente
resultado por
pantalla
 MI PRIMERA VENTANA
Para crear una ventana debemos EXTENDER (Propiedad de Herencia) o
HEREDAR métodos de la clase "JFRAME". Esta clase esta contenida en la
librería SWING que nos permite la creación y gestión de gráficos,
ventanas, botones, etc. Normalmente esta se ayuda de la librería AWT
para la gestión de las mismas. Todo lo que tenga que ver con este tipo
de librerías lo veremos en otro POST. Por ahora veremos un primer
programa para poder crear una venta, en este caso solo utilizaremos la
librería SWING.
¿Cómo crear ventanas para
netbeans y HTML?
 NetBeans

Primero vamos a crear un nuevo proyecto al que vamos a colocarle ventana, como
ven sin crear principalmente el main class.
Como no tiene un paquete nuestro proyecto crearemos uno, dentro de source packages.
Crearemos nuestro paquete y lo llamaremos
Ventana.
Después crearemos una nueva clase, y a esta la llamaremos
ventana.
Así quedara nuestra clase pero para nosotros crear interfaces
graficas como ventanas o menús que interactúan con el usuario
deberemos invocar el Jframe, El Jframe es una clase
establecida por netbeans para la creación de ventanas pero
para ello deberemos importar la colección de rutinas de java o
biblioteca , javax.swing para renderizar los componentes de
interfaz de usuario usando rutinas de dibujado 2D.
Así crearemos nuestra clase tipo Jframe e Importaremos la biblioteca grafica
javax.swing. Como ven en nuestro código agregamos el import
javax.swing.Jframe; para invocar la biblioteca grafica porque sin ello no nos
dejaría utilizar la clase Jframe ya que esta clase viene de la biblioteca
Javax.swing, y utilizaremos la función extends para que nuestra clase
ventana tome como base otra clase ya existente que en este caso seria
Jframe.
Luego crearemos nuestro constructor de la clase Ventana para establecer el tamaño
de nuestra ventana para ello utilizaremos this.setsize(width,height); y dentro de
parámetros estaría como queremos declarar la anchura y la altura de nuestra
ventana. Para poder ejecutarlo necesitaremos el main, Crearemos una nueva clase
que llamaremos principal.
Dentro de nuestra nueva clase colocaremos el main para poder hacer que
se muestre nuestra venta necesitaremos crear un objeto de la
claseventana como ven en la imagen lo vamos a llamar v1 y así quedaría
la sintaxis: ventana v1= new Ventana(); . Por defecto nuestra ventana no
estará visible así que utilizaremos este comando para hacerla ver:
v1.setVisible(true); . Y ya tendríamos nuestra ventana
Y así se mostraría nuestra
ventana.
 Menú a la Java

La barra de menú está compuesta por menúes, que a su vez están

compuestos de ítems. Por ejemplo la barra de menú la declaramos
con:

MenuBar barraMenu = new MenuBar();

y le agregamos los menús Archivo y Edit con:

barraMenu.add(menuArchivo);
barraMenu.add(menuEdit);

Finalmente la declaramos como EL menú de la ventana (Frame):

setMenuBar(barraMenu);

Cada uno de los menús los declaramos previamente:

Menu menuArchivo = new Menu("&Archivo");

Menu menuEdit = new Menu("&Edit");

A su vez, el método add está presente también en la clase
Menú y nos permite agregar los ítems:

mArchivoAbrir = new MenuItem("&Abrir...");

mArchivoGrabar = new MenuItem("&Grabar...");

mArchivoSalir = new MenuItem("&Salir");

menuArchivo.add(mArchivoAbrir);

menuArchivo.add(mArchivoGrabar);

menuArchivo.add(new MenuItem("-"));

menuArchivo.add(mArchivoSalir);

A estos ítems los hemos declarado como globales en la clase

para usarlos luego en los eventos. Noten además que

menuArchivo.add(new MenuItem("-"));
Finalmente, en nuestro manejador de eventos
simplemente necesitamos verificar si se eligió un
ítem probando si el evento ocurrió sobre el ítem
determinado:

if ((e.id==Event.WINDOW_DESTROY)||
(e.target==mArchivoSalir)) {
if (editado) System.out.println("Pedir
confirmación!\n");
if (enApplet) dispose();
else System.exit(0);
}
if (e.target==mArchivoAbrir) CargarArchivo();
................
if (e.target==mEditTodo) contenido.selectAll();
En resumen lo que hago es:

• Si eligió Archivo/Salir (o alt-F4 o lo que sea) salgo del

programa
• Si eligió Archivo/Abrir, llamo al método CargarArchivo
• Si eligió Archivo/Grabar, llamo al método GrabarArchivo
• Si eligió Edit/Cortar copio el texto seleccionado a mi
clipboard y borro la selección
• Si eligió Edit/Copiar sólo copio el texto seleccionado a mi
clipboard
• Si eligió Edit/Pegar borro el texto seleccionado e inserto el
de mi clipboard
• Si eligió Edit/Seleccionar_todo marco todo el texto

En todos los casos, si se modifica el texto del contenido lo indico

poniendo editado en true; lo mismo si presiono una tecla sobre el
área de edición:

if ((e.id==Event.KEY_PRESS)&&(e.target==contenido))
editado=true;
Un par de aclaraciones:

• getSelectionStart() y getSelectionEnd() marcan los

límites del texto seleccionado (si no lo hay, son iguales).

• getSelectedText() devuelve el texto seleccionado en el

TextArea.

• replaceText() reemplaza una parte (o todo) del TextArea

por un String.

• insertText() inserta un String en un lugar determinado del

TextArea.

• selectAll() selecciona todo el texto del TextArea.

• MenuItem.enable() habilita un ítem de menú. Lo utilizo

para habilitar Edit/Pegar sólo luego de cortar o copiar
algo a mi clipboard.

• En el caso del ítem Archivo/Grabar, lo habilito o no

dependiendo de la variable editado, utilizando la otra
forma de enable: MenuItem.enable(boolean).
Ejemplo de menú java
 Diálogos
En Java disponemos de la clase Dialog para crear diálogos, es
decir, ventanitas temporarias para entradas de usuario, que
dependen de otra.

Si bien podemos crear diálogos a medida usando la clase

Frame, se supone que usar diálogos debe ser más fácil. La
realidad es que por ahora no se puede usar mucho más que los
diálogos estándar, ya que las implementaciones actuales de
Java tienen un problema: en algunas plataformas el programa
que abre el diálogo sigue, en lugar de esperar que se cierre el
diálogo y devuelva la respuesta.

Por eso hemos puesto solamente una indicación adonde

debería haber un diálogo de confirmación:

if (editado) System.out.println("Pedir confirmación!\n");

En ese lugar deberíamos llamar por ejemplo a un
diálogo que nos permita decidir por sí o por no:

If (editado) {
sino = new ConfirmarDlg(this,"Archivo modificado!");
if (sino.getResponse()==true) ....;
else ....;
}

Por lo pronto, veamos un caso simple con la clase FileDialog:

FileDialog fd = new FileDialog(this,"Abrir...",FileDialog.LOAD);

fd.show();
nombreArchivo = fd.getFile();
Primero declaramos una variable de tipo FileDialog, y
creamos la instancia con new. Como parámetros se pasa
primero la ventana, el título de la ventanita de diálogo, y una
constante LOAD o SAVE que indica si el diálogo es para
cargar o grabar un archivo.

El método show() muestra el diálogo y espera que

seleccionemos y presionemos Ok o Cancel, aquí es donde fallan
los demás diálogos ya que es programa sigue sin esperar.

Finalmente, el diálogo se cierra pero no se elimina el objeto .

Esto hace que aunque no lo veamos podamos llamar al método
getFile() sobre este objeto, que nos devuelve el nombre del
archivo seleccionado o null si se presionó Cancel.
 DibuJava

Además de los componentes estándar (botones, listas, etc.),

hay un componente para dibujo "libre" que nos permite
implementar cualquier otro tipo de control: la clase Canvas.
Típicamente se usa para dibujar, y corresponde a una zona
rectangular dentro de una ventana.

La clase en sí no hace prácticamente nada; el programador

debe definir una subclase de Canvas a la que el AWT le
envía todos los eventos de mouse y teclado. Redefiniendo
los métodos gotFocus, lostFocus,keyDown, keyUp,
mouseEnter, mouseExit, mouseMove, mouseDrag,
mouseDown y mouseUp, el programador puede hacer lo
que se le ocurra dentro de ese rectángulo.
 El applet-container
En primer lugar hemos tenido en cuenta que un Applet es un
Panel, y por lo tanto también un Container, así que en lugar
de crear una ventana aparte simplemente le agregamos dos
componentes: un Label y un Canvas.

zonaDib.resize(new Dimension (200,200));

add("North", label);

add("Center", zonaDib);

resize(300,250);

El método resize, sobre la clase miCanvas, nos permite

redimensionar el mismo al tamaño deseado. Igualmente,
usamos resize sobre el applet para darle un tamaño
adecuado.
Ejemplo applet-container
 Vectores
Los vectores nos permiten hacer arreglos de cualquier tipo de
objeto, y referirnos individualmente a cualquier elemento del
vector, aunque para utilizarlos (debido a que para java el vector
contiene objetos genéricos) tendremos que decirle qué clase de
objeto es mediante un "cast".

En primer lugar creamos una variable (global a la clase)

llamada v, de clase Vector, y sin asignarle un tamaño
definido:

Vector v = new Vector();

Al crear un nuevo rectángulo agregamos un elemento

(objeto) al vector mediante el método add:

v.addElement( new Rectangle(x, y, 0, 0) );

Para acceder a un atributo de un objeto del vector no

basta utilizar directamente el vector, como:

v.lastElement().x
Es necesario aclarar explícitamente que el elemento
en cuestión es un rectángulo, ya que el vector puede
contener objetos de cualquier tipo. Para eso usamos
el casting:

(Rectangle)v.lastElement().x

En nuestro código original reemplazaríamos por:

(Rectangle)v.lastElement().resize( x -
(Rectangle)v.lastElement().x, ......

Pero es más claro si usamos una variable local de

clase Rectangle, le asignamos el mismo objeto que
acabamos de agregar al vector, y lo usamos en su
lugar:

Rectangle r = (Rectangle)v.lastElement();
r.resize( x - r.x, y - r.y );
Finalmente, en el método Paint() no podemos asignar el
elemento hasta no saber que existe. Así que un if nos
permite verificar que el tamaño del vector es mayor que
cero, y un for nos permite dibujarlos uno por uno. Se
puede acceder a todos los elementos, uno por uno,
mediante el método elementAt(x). El método size() nos
da la cantidad de elementos (el primero es el número 0,
y así):

if (v.size() > 0)
for (i=0; i<v.size(); i++) {
Rectangle box =
cortarRect( (Rectangle)v.elementAt( i ), d);
g.drawRect(box.x, box.y, box.width-1,
box.height-1);
}