Java

Aprenda Java
By: Martín Alejandro Guerra Hernández
Email: maghtin@yahoo.com.mx
WebSite: http://mx.geoities.com/maghtin/
Jiquilpan, Michoacán. Enero del 2007
PDF created with pdfFactory Pro trial version www.pdffactory.com

Índice Pagina
Breve Historia de Java …………………………………………………………………… 1

Introducción a Java……………………………………………………………………….. 1
El Entorno de Desarrollo de Java ……………………………………………………….. 2
Programación Orientada a Objetos …………………………………………………….. 3
Programación en Java……………………………………………………………………. 4
Palabras Reservadas ………………………………………………………………… 4
Tipos de Variables…………………………………………………………………….. 4
Visibilidad y Vida de las Variables………………………………………………….. 5
Operadores de Java…………………………………………………………………... 7
Sentencias de Entrada y Salida de Datos………………………………………….. 9
Estructura de un Programa en Java………………………………………………… 10
Estructuras de Control…………………………………………………………………….. 14
Sentencia de Control if………………………………………………………………... 14
Sentencia de Control switch………………………………………………………….. 16
Bucles…………………………………………………………………………………… 19
Bucle o ciclo while…………………………………………………………………. 19
Bucle o ciclo for……………………………………………………………………. 22
Bucle o ciclo do-while……………………………………………………………... 25
Comparación de los Bucles………………………………………………………. 25
Arreglos…………………………………………………………………………………….. 27
Introducción a los Applet………………………………………………………………….. 31
Estructura de un Applet……………………………………………………………….. 31
Incrustar un Applet en una Pagina Web…………………………………………….. 32
Clase Graphics…………………………………………………………………………….. 33
Cuadros de Dialogo……………………………………………………………………….. 37
Manejo de imágenes……………………………………………………………………… 39
Herramientas Graficas de AWT………………………………………………………….. 40
Control Label (etiquetas)……………………………………………………………... 40
Clase TextField (cajas de texto)……………………………………………………... 41
Control Button (botones)……………………………………………………………... 41
Control Checkbox (casillas de verificación)………………………………………... 41
Control List (lista desplegable)……………………………………………………… 42
Control Scrollbar (barras de desplazamiento)…………………………………….. 43
Referencias Bibliograficas……………………………………………………………….. 47

Curso Básico de Java 2 By: m @gh
BREVE HISTORIA DE JAVA
Java surgió en 1991 cuando un grupo de ingenieros de Sun Microsystems trataron de
diseñar un nuevo lenguaje de programación destinado a electrodomésticos. La reducida
potencia de cálculo y memoria de los electrodomésticos llevó a desarrollar un lenguaje
sencillo capaz de generar código de tamaño muy reducido.
Debido a la existencia de distintos tipos de CPUs y a los continuos cambios, era importante
conseguir una herramienta independiente del tipo de CPU utilizada. Desarrollaron un código
“neutro” que no dependía del tipo de electrodoméstico, el cual se ejecutaba sobre una
“máquina hipotética o virtual” denominada Java Virtual Machine (JVM). Era la JVM quien
interpretaba el código neutro convirtiéndolo a código particular de la CPU utilizada. Esto
permitía lo que luego se ha convertido en el principal lema del lenguaje: “Write Once, Run
Everywhere”. A pesar de los esfuerzos realizados por sus creadores, ninguna empresa de
electrodomésticos se interesó por el nuevo lenguaje.
Como lenguaje de programación para computadores, Java se introdujo a finales de 1995. La

clave fue la incorporación de un intérprete Java en la versión 2.0 del programa Netscape
Navigator, produciendo una verdadera revolución en Internet. Java 1.1 apareció a principios
de 1997, mejorando sustancialmente la primera versión del lenguaje. Java 1.2, más tarde
rebautizado como Java 2, nació a finales de 1998, puede descargarlo de Sun Microsystems:
http://java.sun.com/j2se/1.5.0/download.jsp
Al programar en Java no se parte de cero. Cualquier aplicación que se desarrolle “cuelga” (o

se apoya, según como se quiera ver) en un gran número de clases preexistentes. Algunas
de ellas las ha podido hacer el propio usuario, otras pueden ser comerciales, pero siempre
hay un número muy importante de clases que forman parte del propio lenguaje (el API o
Application Programming Interface de Java). Java incorpora en el propio lenguaje muchos
aspectos que en cualquier otro lenguaje son extensiones propiedad de empresas de software
o fabricantes de ordenadores (threads, ejecución remota, componentes, seguridad, acceso a
bases de datos, etc.).
La compañía Sun describe el lenguaje Java como “simple, orientado a objetos, distribuido,
interpretado, robusto, seguro, de arquitectura neutra, portable, de altas prestaciones,
multitarea y dinámico”.
INTRODUCCIÓN A JAVA
Los programas desarrollados en Java presentan diversas ventajas frente a los desarrollados
en otros lenguajes como C/C++. La ejecución de programas en Java tiene muchas
posibilidades: ejecución como aplicación independiente (Stand-alone Application),
ejecución como applet, ejecución como servlet, etc. Un applet es una aplicación especial
que se ejecuta dentro de un navegador o browser (por ejemplo Netscape Navigator o Internet
Explorer) al cargar una página HTML desde un servidor Web. El applet se descarga desde el
servidor y no requiere instalación en el ordenador donde se encuentra el browser. Un servlet
es una aplicación sin interface gráfica que se ejecuta en un servidor de Internet. La ejecución
como aplicación independiente es análoga a los programas desarrollados con otros
lenguajes.
By: m @ gh 1

Además de incorporar la ejecución como Applet, Java permite fácilmente el desarrollo tanto
de arquitecturas cliente-servidor como de aplicaciones distribuidas, consistentes en crear
aplicaciones capaces de conectarse a otros ordenadores y ejecutar tareas en varios
ordenadores simultáneamente, repartiendo por lo tanto el trabajo. Aunque también otros
lenguajes de programación permiten crear aplicaciones de este tipo, Java incorpora en su
propio API estas funcionalidades. La versión 1.3 contenía 76 packages y aproximadamente
2000 elementos entre clases, interfaces, excepciones, etc.
EL ENTORNO DE DESARROLLO DE JAVA

Existen distintos programas comerciales que permiten desarrollar código Java. La compañía
Sun, creadora de Java, distribuye gratuitamente el Java Development Kit (JDK). Se trata de
un conjunto de programas y librerías que permiten desarrollar, compilar y ejecutar programas
en Java. Incorpora además la posibilidad de ejecutar parcialmente el programa, deteniendo
la ejecución en el punto deseado y estudiando en cada momento el valor de cada una de las
variables (con el denominado Debugger), destinado a la detección y corrección de errores.
El compilador de Java, es de una de las herramientas de desarrollo incluidas en el JDK.

Realiza un análisis de sintaxis del código escrito en los archivos fuente de Java (extensión
*.java). Si no encuentra errores en el código genera los archivos compilados (extensión
*.class). En otro caso muestra la(s) línea(s) errónea(s).Dicho compilador se llama javac.exe
La Java Virtual Machine, se planteó la necesidad de conseguir un código capaz de

ejecutarse en cualquier tipo de máquina. Una vez compilado no debería ser necesaria
ninguna modificación por el hecho de cambiar de procesador o de ejecutarlo en otra
máquina. La clave consistió en desarrollar un código “neutro” el cual estuviera preparado
para ser ejecutado sobre una “máquina hipotética o virtual”, denominada Java Virtual
Machina (JVM). Es esta JVM quien interpreta este código neutro convirtiéndolo a código
particular de la CPU utilizada. Se evita tener que realizar un programa diferente para cada
CPU o plataforma. La JVM es el intérprete de Java. Ejecuta los “bytecodes” (archivos
compilados con extensión *.class) creados por el compilador de Java (javac.exe).
Las variables PATH y CLASSPATH, el desarrollo y ejecución de aplicaciones en Java

exige que las herramientas para compilar (javac.exe) y ejecutar (java.exe) se encuentren
accesibles. La computadora, desde una ventana de comandos de MS-DOS, sólo es capaz de
ejecutar los programas que se encuentran en los directorios indicados en la variable PATH
de la computadora (o en el directorio activo). Si se desea compilar o ejecutar código en Java,
el directorio donde se encuentran estos programas (java.exe y javac.exe) deberá
encontrarse en el PATH.
Una forma general de indicar estas dos variables es crear un archivo por lotes de MS-DOS
(*.bat) donde se indiquen dichos valores. Cada vez que se ejecute MS-DOS será necesario
ejecutar este archivo *.bat para su asignación adecuada. Un archivo sería jdk115.bat: ?
set JAVAPATH=C:\ jdk1.1.5
set PATH=.;%JAVAPATH%\bin;%PATH%
set CLASSPATH=.\ ;%JAVAPATH%\lib\classes.zip;%CLASSPATH%
lo cual sería válido en el caso de que el JDK estuviera situado en el directorio C:\jdk1.1.5
By: m @ gh 2

PROGRAMACIÓN ORIENTADA A OBJETOS (OOP)
Los Objetos, son elementos declarados de una clase. Un objeto tiene una estructura y al
igual que los objetos del mundo real comparten dos características: estado y
comportamiento. El estado de un objeto son sus atributos (propiedades) y el comportamiento
(operaciones).
La Clase, es una agrupación de datos (variables o campos) y de funciones (métodos) que

operan sobre esos datos. A estos datos y funciones pertenecientes a una clase se les
denomina variables o métodos de instancia.
Clase Objeto Estado Comportamiento

Persona hombre, mujer nombre, altura, peso, edad comer, dormir, leer, hablar
Animales perro, lobo, coyote nombre, color, raza ladrar, correr, oler
Vehículos Automóvil, motocicleta ruedas, frenos, color, marca frenar, acelerar
La Programación Orientada a Objetos se basa en la programación de clases. Un programa

se construye a partir de un conjunto de clases. Se considera un método de implementación
en el que los programas se organizan como colecciones cooperativas de objetos, cada uno
de los cuales representa una instancia de alguna clase, y cuyas clases son, todas ellas
miembros de una jerarquía de clases unidas mediante relaciones de herencia.
En Java, las clases soportan 3 características fundamentales de la POO: encapsulación,

herencia y polimorfismo
Encapsulación, las clases pueden ser declaradas como públicas (public) y como package
(accesibles sólo para otras clases del package). Las variables miembro y los métodos
pueden ser public, private, protected. De esta forma se puede controlar el acceso y evitar un
uso inadecuado.
Herencia, una clase puede derivar de otra (extends), y en ese caso hereda todas sus
variables y métodos. Una clase derivada puede añadir nuevas variables y métodos y/o
redefinir las variables y métodos heredados. Ejemplo:
class No mbre_Clase_Derivada extend No mbre_Clase_Base
Clase: Figuras
class Triangulo extend Figuras
Polimorfismo, los objetos de distintas clases pertenecientes a una misma jerarquía o que
implementen una misma interface pueden tratarse de una forma general e individualizada, al
mismo tiempo. Ejemplo:
class Circulo extend Figuras // Se aplica la herencia
{ …
public void copiar(Figuras f) { … }; // Se aplica el polimorfismo
}
class Triangulo extend Figuras // Se aplica la herencia
{ …
public void copiar(Figuras f) { … }; // Se aplica el polimorfismo
}
By: m @ gh 3

PROGRAMACIÓN EN JAVA
En este apartado se presentan las características generales de Java como lenguaje de
programación. Es muy similar a C/C++, lenguajes en los que está inspirado.
Una variable es un nombre que contiene un valor que puede cambiar a lo largo del
programa. Desde el punto de vista del papel o misión en el programa, las variables son:
1. Variables miembro de una clase: Se definen en una clase, fuera de cualquier método;
pueden ser tipos primitivos (char, byte, short, int, long, float, double, boolean) o
referencias (arrays u objetos de una determinada clase).
2. Variables locales: Se definen dentro de un método o más en general dentro de cualquier

bloque entre llaves { }. Se crean en el interior del bloque y se destruyen al finalizar dicho
bloque. Pueden ser también tipos primitivos o referencias.
Nombres de Variables
Los nombres de variables en Java se pueden crear con mucha libertad. Pueden ser
cualquier conjunto de caracteres numéricos y alfanuméricos, sin algunos caracteres
especiales utilizados por Java como operadores o separadores ( ,.+-*/ etc.).
Existe una serie de palabras reservadas las cuales tienen un significado especial para Java
y por lo tanto no se pueden utilizar como nombres de variables. Dichas palabras son:
Abstract Boolean Break byte case Match

Char Class Const continue default Do
Double Else extends final finally Flota
For Goto If implements import Instanceof
Int Interface Long native new Null
Package private protected public return Short
Static super Switch synchronized this Throw
Throws transient Try void volatile While
Tipos Primitivos de Variables

Se llaman tipos primitivos de variables de Java a aquellas variables sencillas que contienen
los tipos de información más habituales: valores boolean, caracteres y valores numéricos
enteros o de punto flotante.
Java dispone de ocho tipos primitivos de variables: un tipo para almacenar valores true y
false (boolean); un tipo para almacenar caracteres (char), y 6 tipos para guardar valores
numéricos, cuatro tipos para enteros (byte, short, int y long) y dos para valores reales de
punto flotante (float y double). Los rangos y la memoria que ocupa cada uno de estos tipos
se muestran a continuación:
Tipo de variable Descripción

boolean 1 byte. Valores true y false
char 2 bytes. Unicode. Comprende el código ASCII
byte 1 byte. Valor entero entre -128 y 127
By: m @ gh 4

Tipo de variable Descripción
short 2 bytes. Valor entero entre -32768 y 32767
int 4 bytes. Valor entero entre -2.147.483.648 y 2.147.483.647
Long 8 bytes. Valor entre -9.223.372.036.854.775.808 y
9.223.372.036.854.775.807
float 4 bytes (entre 6 y 7 cifras decimales equivalentes). De -3.402823E38 a
-1.401298E-45 y de 1.401298E-45 a 3.402823E38
fouble 8 bytes (unas 15 cifras decimales equivalentes). De
-1.79769313486232E308 a -4.94065645841247E-324 y de
4.94065645841247E-324 a 1.79769313486232E308
Cómo se definen e inicializan las variables

Una variable se define especificando el tipo y el nombre de dicha variable. Estas variables
pueden ser tanto de tipos primitivos como referencias a objetos de alguna clase
perteneciente al API de Java o generada por el usuario. Si no se especifica un valor en su
declaración, las variable primitivas se inicializan a cero (salvo boolean y char, que se
inicializan a false y '\0'). Análogamente las variables de tipo referencia son inicializadas por
defecto a un valor especial: null.
Un tipo particular de referencias son los arrays o vectores, sean éstos de variables primitivas
(por ejemplo, un vector de enteros) o de objetos. En la declaración de una referencia de tipo
array hay que incluir los corchetes []. En los siguientes ejemplos aparece cómo crear un
vector de 10 números enteros y cómo crear un vector de elementos MyClass. Java garantiza
que los elementos del vector son inicializados a null o a cero (según el tipo de dato) en caso
de no indicar otro valor.
Ejemplos de declaración e inicialización de variables:

int x; // Declaración de la variable primitiva x. Se inicializa a 0
int y = 5; // Declaración de la variable primitiva y. Se inicializa a 5
unaRef = new MyClass(); // La referencia “apunta” al nuevo objeto creado
// Se ha utilizado el constructor por defecto
int [ ] vector; // Declaración de un array. Se inicializa a null
vector = new int[10]; // Vector de 10 enteros, inicializados a 0
double [ ] v = {1.0, 2.65, 3.1}; // Declaración e inicialización de un vector de 3
// elementos con los valores entre llaves
MyClass [ ] lista=new MyClass[5];// Se crea un vector de 5 referencias a objetos
// Las 5 referencias son inicializadas a null
VISIBILIDAD Y VIDA DE LAS VARIABLES

Dependiendo del lugar donde se definan las variables de Java, estas se pueden utilizar en la
totalidad del programa, dentro de un método o solo temporalmente dentro de un bloque de
sentencias. La zona de un programa en la que una variable está activa se denomina: ámbito,
alcance o scope. El ámbito (alcance) de una variable se extiende desde la sentencia que la
define hasta los límites del bloque que la contiene. Según el ámbito los tipos básicos son:
By: m @ gh 5

Variables Locales, son aquellas definidas en el interior de un método y son visibles solo en
ese método específico. Y se caracterizan por: no puede ser modificada por ninguna
sentencia externa al método, los nombres de las variables locales no han de ser únicos (2 o
mas métodos pueden definir la misma variable) cada variable pertenece al método que esta
declarada, no existen en memoria hasta que se ejecuta el método. Lo cual permite ahorrar
memoria.
Variables de Clase, los miembros de una clase son métodos o variables, las variables de
clase se declaran en una clase, fuera de los métodos; al menos son visibles desde cualquier
método de la clase y se referencian simplemente con su nombre. Y se caracteriza por: se le
asigna memoria cuando se crea el objeto de la clase y permanece hasta que el objeto es
liberado o termina la ejecución del programa.
? Ejemplo:
class Numeros
{
int num1, num2; // Declaración de variables Miembro de la Clase
double promedio()
{
double x; // Declaración de variable Local
num1 = 21; // Esta variable es visible por ser Miembro de la Clase
}
double sumas()
{
float x; // Declaración de variable Local. Note que es igual a la del otro método.
num2 = 22; // Esta variable es visible por ser Miembro de la Clase
}
}
Visibilidad de las variables de una clase de menos accesible a más:

private, solo accesible dentro de la clase.
default (sin modificador), accesible por cualquier clase del paquete.
protected, accesible en todo el paquete y en clases derivadas de otros paquetes.
public, accesible desde cualquier clase.
Uno de los aspectos más importantes en la programación orientada a objetos (OOP) es la

forma en la cual son creados y eliminados los objetos. En Java la forma de crear nuevos
objetos es utilizando el operador new. Cuando se utiliza el operador new, la variable de tipo
referencia guarda la posición de memoria donde está almacenado este nuevo objeto. Para
cada objeto se lleva cuenta de por cuántas variables de tipo referencia es apuntado. La
eliminación de los objetos la realiza el programa denominado garbage collector, quien
automáticamente libera o borra la memoria ocupada por un objeto cuando no existe ninguna
referencia apuntando a ese objeto. Lo anterior significa que aunque una variable de tipo
referencia deje de existir, el objeto al cual apunta no es eliminado si hay otras referencias
apuntando a ese mismo objeto.
By: m @ gh 6

OPERADORES DE JAVA
Java es un lenguaje rico en operadores, que son casi idénticos a los de C/C++. Estos
operadores se describen brevemente en los apartados siguientes.
Operadores aritméticos
Son operadores binarios (requieren siempre dos operandos) que realizan las operaciones
aritméticas habituales: suma (+), resta (-), multiplicación (*), división (/) y resto de la
división (%).
Operadores de asignación
Los operadores de asignación permiten asignar un valor a una variable. El operador de
asignación por excelencia es el operador igual (=). La forma general de las sentencias de
asignación con este operador es:
Operador Utilización Expresión equivalente
+= op1 += op2 op1 = op1 + op2
-= op1 -= op2 op1 = op1 - op2
*= op1 *= op2 op1 = op1 * op2
/= op1 /= op2 op1 = op1 / op2
%= op1 %= op2 op1 = op1 % op2
Operador instanceof
El operador instanceof permite saber si un objeto pertenece o no a una determinada clase.
Es un operador binario cuya forma general es, objectName instanceof ClassName y que
devuelve true o false según el objeto pertenezca o no a la clase.
Operadores incrementales
Java dispone del operador incremento (++) y decremento (--). El operador (++) incrementa
en una unidad la variable a la que se aplica, mientras que (--) la reduce en una unidad. Estos
operadores se pueden utilizar de dos formas:
Operadores relacionales
Los operadores relacionales sirven para realizar comparaciones de igualdad, desigualdad y
relación de menor o mayor.
El resultado de estos operadores es siempre un valor boolean (true o false) según se
cumpla o no la relación considerada. La Tabla muestra los operadores relacionales de Java.
Operador Utilización El resultado es true
> op1 > op2 si op1 es mayor que op2
>= op1 >= op2 si op1 es mayor o igual que op2
< op1 < op2 si op1 es menor que op2
<= op1 <= op2 si op1 es menor o igual que op2
== op1 == op2 si op1 y op2 son iguales
!= op1 != op2 si op1 y op2 son diferentes
Operadores lógicos
Los operadores lógicos se utilizan para construir expresiones lógicas, combinando valores
lógicos (true y/o false) o los resultados de los operadores relacionales. La Tabla 2.4
muestra los operadores lógicos de Java. Debe notarse que en ciertos casos el segundo
By: m @ gh 7

operando no se evalúa porque ya no es necesario (si ambos tienen que ser true y el primero
es false, ya se sabe que la condición de que ambos sean true no se va a cumplir). Esto
puede traer resultados no deseados y por eso se han añadido los operadores (&) y (|) que
garantizan que los dos operandos se evalúan siempre.
Operador Nombre Utilización Resultado

&& AND op1 && op2 true si op1 y op2 son true. Si op1 es false ya no se
evalúa op2
|| OR op1 || op2 true si op1 u op2 son true. Si op1 es true ya no se
evalúa op2
! negación ! op true si op es false y false si op es true
& AND op1 & op2 true si op1 y op2 son true. Siempre se evalúa op2
| OR op1 | op2 true si op1 u op2 son true. Siempre se evalúa op2
Operador de concatenación de cadenas de caracteres (+)

El operador más (+) se utiliza también para concatenar cadenas de caracteres. Por ejemplo,
para escribir una cantidad con un rótulo y unas unidades puede utilizarse la sentencia:
System.out.println("El total asciende a " + result + " unidades");
donde el operador de concatenación se utiliza dos veces para construir la cadena de
caracteres que se desea imprimir por medio del método println(). La variable numérica
result es convertida automáticamente por Java en cadena de caracteres para poderla
concatenar.
Precedencia de operadores
El orden en que se realizan las operaciones es fundamental para determinar el resultado de
una expresión. Por ejemplo, el resultado de x/y*z depende de qué operación (la división o el
producto) se realice primero. La siguiente lista muestra el orden en que se ejecutan los
distintos operadores en un sentencia, de mayor a menor precedencia:
postfix operators [] . (params) expr++ expr--
unary operators ++expr --expr +expr -expr ~ !
creation or cast new (type)exp.
multiplicative */%
Additive +-
Shift << >> >>>
Relational < > <= >= instanceof
Equality == !=
Bitwise AND &
Bitwise exclusive OR ^
Bitwise inclusive OR |
Logical AND &&
Logical OR ||
Condicional ?:
Assignment = += -= *= /= %= &= ^= |= <<= >>= >>>=
En Java, todos los operadores binarios, excepto los operadores de asignación, se evalúan
de izquierda a derecha. Los operadores de asignación se evalúan de derecha a izquierda,
lo que significa que el valor de la derecha se copia sobre la variable de la izquierda.
By: m @ gh 8

SENTENCIAS DE ENTRADA/SALIDA DE DATOS
En Java, la entrada y salida se lee y escribe en flujos (streams). La fuente básica de entrada
de datos es el teclado y la fuente de salida de datos es la pantalla. La clase System define
dos referencias a objetos para la gestión de entrada y de salida:
Syste m.i n para entrada por teclado
Syste m.out para la salida por pantalla
Salida (System.out)
El objeto out definido en la clase System esta asociado con el flujo de salida, que dirige los
datos a consola y permite visualizarlos en la pantalla de su equipo:
Syste m.out es una referencia a un objeto de clase PrintStream, tiene métodos que se
utilizarán con mucha frecuencia:
print( ) transfiere una cadena de caracteres al buffer de pantalla.
println( ) transfiere una cadena de caracteres y el carácter de fin de línea al buffer de la
pantalla.
? Ejemplo:
Syste m.out.print(“Este es un mensaje en java”);
Syste m.out.println(“Este es un mensaje en java y el cursor lo envía a la siguiente línea”);
Ent rada (System.i n)

El objeto esta asociado al flujo estándar de entrada, que por defecto es el teclado. Entre los
metodos de clase se encuentran read(), que devuelve el carácter actual en el buffer de
entrada.
? Ejemplo:
char letra;
letra = (char) Syste m.in.read();
No resulta practico el capturar carácter a carácter, es preferible hacerlo línea a línea. Para
ello se utiliza la clase InputStreamReader, de la que se crea un objeto inicializado con
Syste m.in
Bu ffer edReader var iable = new Bu fferedReader( new Input StreamReader(S yst em. in) ;
? Eje mplo:
String nombrex;
BufferedReader entr = ne w BufferedRea der(new InputStrea mReader(Syste m.in);
Syste m.out.print(“Nombre:”);
nombrex = ent r.readline();
Syste m.out.println(“El Nombre Tecleado es: ” + nombrex);
Paquete io (import java.io.*;)

Este paquete se utiliza para entradas de datos por teclado y salidas de datos en pantalla.
Entre los que destacan: System.out.print, BufferedReader, readLine,parseInt, parseFloat.
By: m @ gh 9

Paquete util (import java.util. *;)
Este paquete se utiliza para entradas de datos por teclado y salidas de datos en pantalla.
Entre los que destacan: System.out.print, Scanner, nextLine, nextInt, nextFloat.
Paquete *Clase/Metodo+
io +print Transfiere una cadena de caracteres al buffer de pantalla.
util +print
io *BufferedReader Permite inicializar los métodos para lectura de datos.
util *Scanner
io +readLine Se utiliza para la entrada de datos desde el teclado, devuelve
util +nextLine un objeto cadena con los caracteres leídos hasta encontrar la
marca de fin de línea.
io +parseInt Tiene como argumento una cadena y devuelve el valor entero
correspondiente a la conversión de dígitos de la cadena.
util +nextInt Se utiliza para la entrada de datos desde el teclado, devuelve
un objeto numérico entero.
io +parseFloat Tiene como argumento una cadena y devuelve el valor numérico
decimal correspondiente a la conversión de dígitos de la cadena.
Util +nextFloat Se utiliza para la entrada de datos desde el teclado, devuelve
un objeto numérico decimal.
ESTRUCTURA DE UN PROGRAMA EN JAVA

Un programa en Java se compone de una o más clases. Uno de los métodos de la clase
principal debe ser obligatoriamente el main(). Un método en Java es un grupo de
instrucciones que realiza una o más acciones. Asimismo, un programa contendrá una serie
de declaraciones import que permitirán incluir en el mismo archivo que a su vez constarán
de clases y datos predefinidos por ellos.
import no mbrePaquete.no mbreClase; // Importación de las clases de los paquetes.

public class nombreDelProgra ma // Nombre de la clase principal
{
public static void main(String arg[]) //Método por el que inicia la ejecución del programa.
{
...
}
}
? Ejemplo 1, consiste en enviar un mensaje a la pantalla:

import java.io.*; // Importación de la clase io de entrada/salida.
// * indica que debe importar todos los elementos del paquete java.io
public class Mensa je1 // Nombre de la clase principal, en este caso Mensaje1
{ // Inicia y define la clase principal
{ // Inicia el método principal del programa
Syste m.out.println(“Bienvenidos al Lenguaje Java”); //Envía el mensaje a pantalla.
} // Fin del método principal del programa
} // Fin de la clase principal
By: m @ gh 10

? Ejemplo 2, consiste en enviar mensajes a pantallas con salto de línea.
public class Mensa jeSalto // Nombre de la clase principal, en este caso MensajeSalto
Syste m.out.print(“Soy: Alejandro \n”); //Envía el mensaje con salto de línea
Syste m.out.print(“Aprendiendo un poco \nde Java”); //Envía el mensaje en dos líneas
? Ejemplo 3, consiste en declarar variables de texto y numéricas, asignarles valores e

imprimir esos valores en pantalla.
public class ValorVariables // Nombre de la clase principal, en este caso ValorVariables
int numero; // Declaración de variable local tipo numérica entera.
String nombrex; // Declaración de variable local tipo cadena.
nombrex=“Alejandro”; // Asignación de contenido de texto a la variable de tipo cadena.
numero=12; // Asignación del numero 12 a la variable de tipo numerica.
Syste m.out.println(“Tu eres: ”+nombrex); //Muestra en pantalla el valor de la variable
Syste m.out.println(“Tu numero de la suerte es: ” +numero);
? Ejemplo 4, consiste en declarar variables numéricas, asignarles valores. Calcular la

sumatoria y promedio e imprimir esos valores en pantalla.
public class Su maPro medio // Nombre de la clase principal, en este caso SumaPromedio
int num1, num2, num3; // Declaración de variables locales tipo numérica entera.
int suma, promedio; // Declaración de variables locales tipo numérica entera.
num1=10; num2=7; num3=8; // Asignación de valores numéricos a las variables.
suma=(num1+num2+num3); // Calcula la suma de valores, almacenando el resultado en suma.
promedio=suma/3; // Calcula el promedio, almacenando el resultado en promedio
Syste m.out.println(“La suma es: ”+suma); //Muestra en pantalla el resultado de la suma
Syste m.out.println(“El promedio es: ” +promedio); //Muestra en pantalla el promedio
By: m @ gh 11

? Ejemplo 5, consiste en capturar el Nombre y el año de nacimiento de una persona. Debe
calcular la edad de la persona en segundos de vida. Mostrar en pantalla el nombre con su
edad y el total de segundos de vida. Note que se utiliza la clase io.
import java.io.*; // Importación de la clase io de entrada/salida

public class No mbreEdad // Nombre de la clase principal, en este caso NombreEdad
String nombre; // Declaración de variable local tipo cadena que almacenará el nombre.
int nacio,edad; // Declaración de variables locales tipo numérica entera.
// Almacenará el año de nacimiento y guardará el resultado del calculo.
String auxiliar; // Declaración de variable local tipo cadena que almacenará el año.
float segs; // Declaración de variable local tipo flotante que almacenará los segundos.
// Definida en la clase System, cuya referencia esta dada en el in .

// Inicializa el método para lectura de datos tipo cadena.
BufferedReader entrada=new BufferedReader(new InputStreamReader(S ystem.in));
System.out.println("Nombre"); //Muestra en pantalla el mensaje Nombre
// Método que permite la lectura de datos tipo cadena a través del objeto entrada.
nombre=entrada.readLine(); //El valor pulsado por teclado se almacenará en la variable nombre
System.out.println("Año de Nacimiento"); //Muestra en pantalla el mensaje Año de nacimiento
// Método que permite la lectura de datos tipo cadena a través del objeto entrada.
// Cabe destacar que a través de la clase io, solamente se pueden leer datos tipo cadena.
auxiliar=entrada.readLine();
// Permite hacer la conversión del dato tipo texto a dato tipo numérico entero.
nacio=Integer.parseInt(auxiliar);
// Realiza el calculo de la edad de la persona, almacenando el valor en la variable edad
edad = 2006 - nacio;
// Realiza el calculo del total de segundos de vida, almacenando el valor en la variable segundos
segs = edad * 525600;
// Muestra en pantalla el nombre, la edad y el total de segundos de vida de la persona.

System.out.println("Tu eres"+nombre+" tu edad es:"+edad+ "equivale a"+segs+"seg. de vida" );
By: m @ gh 12

? Ejemplo 6, consiste en capturar el Nombre, el día y tres calificaciones de la Materia de
Programación. Debe calcular el promedio de la materia. Debe mostrar en pantalla el día que
se hizo la entrega, el promedio y el nombre del alumno. Note que se utiliza la clase util.
import java.util.*; // Importación de la clase ut il de entrada/salida

public class No mbrePro medio // Nombre de la clase principal es: NombrePromedio
String nom; // Declaración de variable local tipo cadena que almacenará el nombre.
int dia; // Declaración de variable local tipo numérico que almacenará el día de la entrega
// Declaración de variables locales tipo flotante que almacenará 2 de las calificaciones.

float calif1,calif2;
// Declaración de variables locales tipo double que almacenará 1 calificación y el promedio

double calif3, prom;
// Creamos una clase in de tipo Scanner (del paquete java.util)

// que permite leer datos de tipo: texto, entero, flotante, double.
Scanner in = ne w Scanner(Syste m.in );
Syste m.out.print("No mbre:"); //Muestra en pantalla el mensaje Nombre

nom= in.nextLine(); // Lee un valor de tipo cadena y se lo asigna a la variable nom.
Syste m.out.print("Dia:"); //Muestra en pantalla el mensaje Dia
dia = in.nextInt(); // Lee un valor de tipo entero y se lo asigna a la variable dia
Syste m.out.println("Materia de Progra macion");
Syste m.out.print("1era. Calificacion:");
calif1= in.nextFloat(); // Lee un valor de tipo flotante y se lo asigna a la variable calif1
Syste m.out.print("2da. Calificacion:");
calif2= in.nextFloat(); // Lee un valor de tipo flotante y se lo asigna a la variable calif2
Syste m.out.print("3era. Calificacion:");
calif3= in.nextDouble(); // Lee un valor de tipo double y se lo asigna a la variable calif3
// Realiza el calculo del promedio y el resultado se lo asigna a la variable prom

prom=(calif1+calif2+calif3)/3;
// Muestra en pantalla el dia, el promedio y en otra linea el nombre del alumno(a)

Syste m.out.println("El dia: "+dia+" se entrego el promedio de: "+pro m);
Syste m.out.println("al alumno(a): "+ no m);
By: m @ gh 13

ESTRUCTURAS DE CONTROL
Estas permiten controlar el comportamiento de un método o de un programa. Las estructuras

de control permiten combinar instrucciones o sentencias individuales en una simple unidad
lógica con un punto de entrada y un punto de salida.
Las instrucciones o sentencias se organizan en tres tipos de estructuras de control que sirven
para controlar el flujo de la ejecución: secuencia, selección (decisión) y repetición. Hasta este
momento solo se han utilizado el flujo secuencial. Una sentencia compuesta es un conjunto
de sentencias encerradas entre llaves que se utiliza para especificar un flujo secuencial.
SENTENCIA DE CONTROL if
En Java, la estructura de control de selección principal es la sentencia if. La sentencia if tiene
dos alternativas o formatos posibles. El formato más sencillo tiene la siguiente sintaxis:
if (condición) sentencia;
donde: la condición es una expresión logica y la sentencia representa la acción ejecutable, si
la condición toma un valor verdadero.
Otro formato de la sentencia if es la sentencia if-else. El formato tiene la siguiente sintaxis:

if (condición) acción 1 , else acción 2
donde: la condición es una expresión logica y la acción 1 se ejecuta si la expresión logica es
verdadera y la acción 2 se ejecuta si la expresión logica es falsa.
? Ejemplo 7, consiste en capturar la edad de la persona. Debe distinguir si esa persona

tiene mayoría de edad o no. Debe mostrar en pantalla la edad y una frase que indique mayor
o menor de edad.
import java.util.*;
public class MayoriaEdad
{
public static void main(String arg[])
{
int edad;
Scanner in = new Scanner(Syste m.in);

Syste m.out.println("Edad:");
edad= in.nextInt();
if (edad >=18)
Syste m.out.print("Eres mayor de e dad, ya puedes votar");
else
Syste m.out.print("Eres menor de e dad");
}
}
By: m @ gh 14

? Ejemplo 8, consiste en capturar una serie de tres números. La aplicación debe distinguir
cuál de los números es el mayor. Debe mostrar en pantalla el mayor de ellos.
/*
Autor: Mart ín Ale jandro Guerra Hernández / m@gh

Descripción: Capt ura 3 Números, la aplic ació n debe deducir cuál es mayor de lo s 3
Fecha: 2-01-07
*/
import java.util.*;
public class Nu mMayor
{
{
float num1, nu m2 , nu m3, nu mmayor;
Syste m.out.println("Aplicacion que Lee 3 Nu meros y deduce cual es mayor ");

Syste m.out.println("1er. Numero:");
num1 = in.nextFloat();
Syste m.out.println("2do. Numero:");
Syste m.out.println("3er. Numero:");
if ((num1>nu m2) && (nu m1 >nu m3))

Syste m.out.print("El numero mayor es:"+nu m1);
else if((num2 > nu m1) && (nu m2 > n u m3))

else if((num3 > nu m1) && (nu m3 > n u m1))

else
System.out.print("Los Nu meros Son Iguales");
}
}
By: m @ gh 15

SENTENCIA DE CONTROL switch
Es una sentencia de Java que se utiliza para seleccionar entre múltiples alternativas. La
sentencia switch es especialmente útil cuando la selección se basa en el valor de una
variable simple o de una expresión simple denominada expresión de control o selector. El
valor de esta expresión puede ser de tipo int, char o boolean, pero no de tipo double, string o
float.
Su sintaxis
switch(selector)
{
case etiqueta 1 : sentencias 1 ;
break;
case etiqueta 2 : sentencias 2 ;
break;
..
..
case etiqueta n :sentencias n ;
break;
default: sentencias n ; // Opcional
break;
donde, la expresión de control o selector se evalúa y se compara con cada una de las
etiquetas del case. La expresión selector debe ser de tipo int, char o bolean, pero no double,
string o flota. Cada etiqueta es un valor único, constante y cada etiqueta debe tener un valor
diferente de los otros. Si el valor de la expresión selector es igual a una de las etiquetas case
por ejemplo: case1, entonces la ejecución comenzará con la primera sentencia1 y continuará
hasta que encuentre una sentencia break (o hasta encontrar el fin de la sentencia de control
switch).
Si el valor del selector no esta listado en ninguna etiqueta case, no se ejecutará ninguna de
las opciones, a menos que especifique una acción por defecto (omisión). La omisión de una
etiqueta default puede crear un error lógico difícil de prever. Aunque la etiqueta default es
opcional, se recomienda su uso, a menos que este absolutamente seguro de que todos los
valores de selector están incluidos en las etiquetas case.
Una sentencia break consta de la palabra reservada break seguida por punto y coma.
Cuando la computadora ejecuta las sentencias siguientes a una etiqueta case, continua
hasta que se alcanza una sentencia break. Si la computadora encuentra una sentencia
break, termina la sentencia switch. Si se omiten las sentencias break, después de ejecutar el
código de case, la computadora ejecutará el código que sigue al siguiente case.
By: m @ gh 16

? Ejemplo 9, consiste en mostrar un lista de opciones (menú) que simulan los días de la
semana. La aplicación debe ser capaz de distinguir que opción eligió y mostrar en pantalla un
mensaje indicando cual ha sido su elección.
/* Autor: Mart ín Ale jandro Guerra Her nández / m@gh

Descripción: Visualiza los días, el usuar io elige opció n y se muest ra su elecció n
Fecha: 2-01-07 */
import java.util.*;
public class MenuNu m
{
{
int opc;

Syste m.out.println("* 1) Lunes *");
Syste m.out.println("* 2) Martes *");
Syste m.out.println("* 3) Miercoles *");
Syste m.out.println("* 4) Jueves *") ;
Syste m.out.println("* 5) Viernes *");
Syste m.out.print("*Elije Opcion (1-5): ");
opc = in.nextInt();
switch(opc)
{
case 1:Syste m.out.println("Valor pulsado 1, corresponde al Lunes");
break;
case 2:Syste m.out.println("Valor pulsado 2, corresponde al Martes");

break;
case 3:Syste m.out.println("Valor pulsado 3, corresponde al Miércoles");

break;
case 4:Syste m.out.println("Valor pulsado 4, corresponde al Jueves");

break;
case 5:Syste m.out.println("Valor pulsado 5, corresponde al Viernes");

break;
default:System.out .println("Valor pulsado No valido");

break;
}
}
}
By: m @ gh 17

? Ejemplo 10, consiste en mostrar un lista de opciones (menú) que simulan los días de la
semana. La aplicación debe ser capaz de distinguir que opción eligió y mostrar en pantalla un
mensaje indicando cual ha sido su elección.
import java.io.*;
public class DiasTxt
{
{
char opc;
Syste m.out.println("* Menu de los días de la semana *");

Syste m.out.println("* A) Lunes *");
Syste m.out.println("* E) Martes *");
Syste m.out.println("* I) Miércoles *");
Syste m.out.println("* O) Jueves *");
Syste m.out.println("* U) Viernes *");
Syste m.out.print("*Elije Opcion:");
opc = (char) Syste m.in.read();
switch(opc)
{
case 'A': case 'a':Syste m.out.println("Valor pulsado A, corresponde Lunes");

break;
case 'E': case 'e': Syste m.out.println("Valor pulsado E, corresponde Martes");

break;
case 'I': case 'i': Syste m.out.println("Valor pulsado I, es Miércoles");

break;
case 'O': case 'o': Syste m.out.println("Valor pulsado O, es Jueves");

break;
case 'U': case 'u': Syste m.out.println("Valor pulsado U, es Viernes");

break;
default: Syste m.out.println("Valor pulsado No valido");

break;
}
}
}
By: m @ gh 18

BUCLES
Las estructuras de programación o estructuras de control permiten tomar decisiones y
realizar un proceso repetidas veces. Son los denominados bifurcaciones y bucles. Dicho en
otras palabras, es cualquier construcción de programa que repite una sentencia o secuencia
de sentencias un número de veces. Las sentencias que se repiten en un bloque se denomina
cuerpo del bucle y cada repetición del cuerpo del bucle se llama iteración del bucle.
BUCLE O CICLO while

Un bucle while tiene una condición del bucle (una expresión logica) que controla la secuencia
de repetición. La posición de esta condición del bucle es delante del cuerpo del bucle y
significa que un bucle while es un bucle pre-test, de modo que cuando se ejecuta el mismo,
se evalua la condición antes de que se ejecute el cuerpo del bucle. Sintaxis:
Forma 1: Forma 2:
while(condicion_bucle) while(condicion_bucle)
sentencia; {
sentencia1;
cuerpo .....
sentencian;
}
donde, while es palabra reservada de Java. condicion_bucle, es la expresión logica.
sentencia, es la sentencia simple o el conjunto de sentencias.
El comportamiento o funcionamiento de un ciclo o bucle while, es el siguiente:

1. Se evalúa la condicion_bucle
2. Si la condición_bucle es verdadera:
a. La sentencia especificada, denominada cuerpo del bucle se ejecuta.
b. Vuelve el control al paso 1.
3. En caso contrario:
El control se transfiere a la sentencia siguiente fuera del bucle o ciclo.
Ejemplo:
contador=0; // Inicialización
while(contador<4) // Prueba/condición
{
Syste m.out.println(“*”);
contador++; // Actualización (incremento)
}
La variable que representa la condición del bucle se denomina variable de control del bucle
debido a que determina si el cuerpo del bucle se repite. La variable de control del bucle debe
ser: inicializada, comprobada y actualizada para que el cuerpo del bucle se ejecute
adecuadamente. Cada etapa se resume así:
Inicialización, al contador se establece con un valor inicial, antes de que alcance el maximo
valor.
Prueba/condición, se comprueba el valor del contador antes de que comience la repetición
de cada bucle (denominada iteración o pasada).
Actualización, el contador se actualiza (su valor se incrementa en 1, mediante el operador
++) durante cada iteración.
By: m @ gh 19

? Ejemplo 11, consiste en mostrar en pantalla los números primos de 1 hasta 30 utilizando
el bucle while.
import java.io.*;
public class Nu msI mpares
{
{
int num;
Syste m.out.println("Lista de Números I mpares 1-30");
nu m=1;
while(num<30)
{
Syste m.out.println(num);
nu m=nu m+2;
}
}
}
? Ejemplo 12, aplicación que permite capturar una serie de números y finaliza la captura
hasta que el usuario teclee el numero 0. Debe utilizar el bucle while, calcular el total de
números capturados y la media de los números. Debe mostrar en pantalla el total y la media
de los números.
import java.util.*;
public class Su maNu ms
{
public static void main(String[] args)
{
int num, su ma, media, cuenta;
Scanner lee = new Scanner(Syste m.i n);
nu m=1; cuenta=0; su ma=0; media=0;
Syste m.out.println("Captura Numero s, hasta que teclee 0");
while(num! =0)
{
Syste m.out.print("Nu mero:");
nu m=lee.ne xtInt();
cuenta++;
su ma=su ma +nu m;
}
media=su ma/(cuenta-1);
Syste m.out.println("Total de Números Capturados: "+(cuenta-1));
Syste m.out.println("La Media es: "+media);
}
}
By: m @ gh 20

? Ejemplo 13, aplicación que permite capturar “X” cantidad de números. Debe utilizar el
bucle while, determinar el total de números capturados que sean pares y cuantos son
impares. Debe mostrar en pantalla la cantidad total de los números pares e impares.
/*

Descripción: Capt ura una cant idad de números, la aplicació n det er mina cuant o s son
pares y cuant os son impares.
Fecha: 2-01-07
*/
import java.util.*;
public class Nu msParI mpar
{
{
int num, au x, cuenta, cant;
int cantpar, cantimpar;
cuenta=0; au x=0;
cantpar=canti mpar=0;
Syste m.out.print("Cantidad de Núme ros a Capturar? ");
cant=lee.nextInt();
while(cuenta<cant)
{
nu m=lee.ne xtInt();
cuenta++;
aux=nu m%2;
if(aux==0)
cantpar++;
else
canti mpar++;
}
Syste m.out.println("Total de Numeros Pares: "+cantpar);
Syste m.out.println("Total de Numeros I mpares: "+canti mpar);
}
}
By: m @ gh 21

BUCLE O CICLO for
El bucle for es el más adecuado para implementar bucles controlados pro contador, que son
bucles en los que un conjunto de sentencias se ejecutan una vez por cada valor de un rango
específico. La sentencia for es la mejor forma de programar la ejecución de un bloque de
sentencias de un numero fijo de veces. El bucle for, tiene la siguiente sintaxis:
for(inicialización; condición _ iteración; incremento_decre mento)

{
sentencia1;
sentencia2;
…..
sentencian;
}
El bucle for contiene cuatro partes:

Parte de inicialización, que inicializa las variables de control del bucle. Se pueden utilizar
variables de control del bucle simples o compuestas. Las variables de control pueden ser
definidas en esta parte.
Parte de condición_iteración, que contiene una expresión lógica que hace que el bucle
realice las iteraciones de las sentencias, mientras que la expresión sea verdadera.
Parte de incrmento_decremento, es la parte del bucle que incrementa o decrementa la
variable de control del bucle.
Sentencias, son las acciones o sentencias que se ejecutarán en cada iteración del bucle.
// Imprimir en pantalla 10 veces el mensaje hola

for(int i=1;i<10;i++)
Syste m.out.println(“Hola”);
? Ejemplo 14, consiste en mostrar en pantalla los números pares, comenzando con el 30 y
terminando en 1, utilizando el bucle for.
import java.io.*;
public class Nu msPares
{
{
int num;
Syste m.out.println("Lista los Numero s Pares del 30-1");
nu m=1;
for(nu m=30;nu m>1;nu m-=2)
{
Syste m.out.println(num);
}
}
}
By: m @ gh 22

? Ejemplo 15, aplicación que permite capturar una serie de 5 números, utilizando el bucle
for. Debe mostrar en pantalla el máximo número. Note que se utiliza la clase util.
/*

Descripción: Capt ura 5 números y det er mina cuál de ellos es el valor máximo.
Fecha: 2-01-07
*/
import java.util.*;
public class Nu mMa x
{
{
int num, ma x, cuenta;
Syste m.out.println("Captura 5 Numer os. Ma xi mo Valor de la Lista");
ma x=0;
for(cuenta=1;cuenta<=5;cuenta ++)
{
nu m=in.ne xtInt();
if(num>ma x)
ma x=nu m;
}
Syste m.out.println("El Valor Máxi mo de la Lista es:"+ma x);
}
}
By: m @ gh 23

? Ejemplo 16, aplicación que permite capturar 5 datos de una compra: nombre del
producto, la cantidad y el precio. Debe calcular el importe por producto, el total de la compra.
Además de otorgar un descuento si el importe de la compra es mayor a $5000 dar un
descuento del 10%, si la compra esta entre $2500-$5000 dar un descuento del 5%, utilizando
el bucle for. Debe mostrar en pantalla el importe total de la compra e indicar el descuento.
import java.util.*;
public class CicloCompra Mcdo
{
public static void main(String []arg)
{
String pdto, obtenido, error;
float cant, precio, importe, subtotal, t otal, desc;
Syste m.out.println("Captura 5 Productos.");
importe=0.0f; subtotal=0.0f; total=0.0f; desc=0.0f;
for(int cuenta=1;cuenta<=5;cuenta++)
{
Syste m.out.print("Producto: ");
pdto=in.nextLine();
Syste m.out.print("Cantidad: ");
cant=in.nextFloat();
Syste m.out.print("Precio:$ ");
precio=in.nextFloat();
importe=cant*precio;
subtotal+=importe;
error=in.nextLine();
}
if(subtotal>5000)
{
desc=subtotal-(subtotal*.10f);
obtenido="10%";
}
else if((subtotal>2500) && (subtotal<=5000))
{
desc=subtotal-(subtotal*.05f);
obtenido="5%";
}
else
{
desc=subtotal;
obtenido="0%";
}
total=desc+(desc*.15f);
S yst em.o ut .print ln( "Tot al de la co mpra: $"+t ot al+"con un descuent o del:"+obt enid o );
}
}
By: m @ gh 24

BUCLE O CICLO do-while
La sentencia do-while se utiliza para especificar un bucle condicional que se ejecuta al
menos una vez. Esta situación se suele dar en algunas circunstancias en las que ha de tener
la seguridad de que una determinada acción se ejecutará una o varias veces, pero al menos
una vez. Su sintaxis es:
do
{
sentencia1;
sentencia2;
…..
sentencian;
}while(expresión)
La construcción do comienza ejecutando las sentencias. Después se evalúa la expresión. Si

la expresión es verdadera, entonces se repite la ejecución de las sentencias. Este proceso
continua hasta que la expresión es falsa.
? Ejemplo 17, aplicación que permite capturar texto hasta que el usuario pulse *. Se
mostrará en pantalla todos los caracteres pulsados por el usuario.
import java.io.*;
public class CicloTexto
{
public static void main(String []arg) throws IO Exception
{
char letra;
S yst em.o ut .print ln( "Teclee el Text o Deseado. Para t erminar pulse * y E nt er") ;
do
{
letra = (char) Syste m.in.read();
}while(letra! ='*');
}
}
COMPARACIÓN DE LOS BUCLES while, for y do-while.

while, el uso más frecuente es cuando la repetición no esta controlada por contador, el test
de condición le precede a cada repetición del bucle; el cuerpo del bucle puede no ser
ejecutado. Se debe utilizar cuando se desea saltar el bucle si la condición es falsa.
for, bucle de conteo, cuando el numero de repeticiones se conoce por anticipado y puede ser
controlado por un contador; también es adecuado para bucles que implican control no
contable del bucle con simples etapas de inicialización y de actualización; el test de la
condición precede a la ejecución del cuerpo del bucle.
do-while, es adecuada cuando se debe asegurar que al menos se ejecute el bucle una vez.
By: m @ gh 25

? Ejemplo 18, aplicación que contiene un menú de las operaciones aritméticas, el cuál lo
debe mostrar al menos una vez, para que el usuario elija la opción y si es necesario capture
los números para realizar la operación. Debe mostrar en pantalla los números de la
operación y el resultado.
import java.util.*;
public class CicloMenu
{
{
int opcion;
float num1, nu m2, result;
do
{
Syste m.out.println("Menu:");
Syste m.out.println("1. Suma");
Syste m.out.println("2. Resta");
Syste m.out.println("3. Suma");
Syste m.out.println("4. Resta");
Syste m.out.println("5. Salir");
Syste m.out.print("Elije Opcion:");
opcion=lee.nextInt();
if(opcion==1)
{
Syste m.out.println("Elijio Su ma ");
Syste m.out.print("Nu mero ");
nu m1=lee.ne xtFloat();
result=nu m1+nu m2;
Syste m.out.println("El resultado de: "+nu m1+" + "+nu m2+" = "+result);
}
if(opcion==2)
{
Syste m.out.println("Elijio Resta ");
result=nu m1-nu m2;
Syste m.out.println("El resultado de: "+nu m1+" - " +nu m2 +" = "+result);
}
}while(opcion! =5 || opcion! =5);
}
}
By: m @ gh 26

ARREGLOS (Arrays)
Un array (lista o tabla) es una secuencia de datos del mismo tipo. Los datos se llaman
elementos del array y se numeran consecutivamente de 0,1,2…..n. El tipo de de elementos
almacenados en el array puede ser cualquier tipo de dato tales como: char, int o float.
Un array puede contener, por ejemplo: la edad de los alumnos, las temperaturas de cada dia
del mes de una ciudad, el total de personas de las ciudades del estado de Michoacán, etc.
La declaración de un array es similar a otros tipos de datos, excepto que se debe indicar al
compilador que es un array y esto se hace con los corchetes. Se pueden colocar de 2 formas
tipo_dato [] identificador;
tipo_dato identificador[];
El primer formato indica que todos los identificadores son arrays del tipo de dato. El segundo
formato es array solo el identificador al que le siguen los corchetes.
Ejemplos:
char cad[], t xt; // cad es un array tipo char, txt es una variable de tipo char.
int [] nums, su ma s; // tanto nums como sumas son declarados arrays de tipo int.
int [] edad = new int [4]; // edad contiene 5 elementos de tipo int
float [] ma x, min = ne w float [4]; // tanto max como min contienen 5 elementos de tipo float
Se deben asignar valores a los elementos de un array antes de utilizarlos, tal como se
asignan valores a variables. Para asignar valores a cada elemento del array, como ejemplo:
nu ms[0]=7; cad[ ]={' m', '@', 'g', 'h'}
nu ms[1]=6;
Cuando se inicializa un array, el tamaño del array se puede determinar automáticamente por
las constantes de inicialización. Estas constantes se separan por comas y se encierran entre
llaves, como los siguientes ejemplos:
int valores [ ]= {1,2,3,4,5} // define un array de 5 elementos de tipo int y se inicializa
char txt[] = {' m', 'g'} // define un array de 2 elementos de tipo char y se inicializa
? Ejemplo 19, aplicación que por medio de un arreglo muestra una lista de colores.
import java.util.*;
public class ArrayColors
{
{
int cta;
String colores [ ]= {"Azul", "Amarillo", "Verde", "Blanco", "Rojo"};
Syste m.out.println("Lista los Colores");
for(cta=0;cta<=4;cta++)
{ Syste m.out.println("Color en la Posicion: "+cta+" "+colores[cta]);
}
}
}
By: m @ gh 27

? Ejemplo 20, aplicación que le permite al usuario capturar texto y lo almacena en un
arreglo. Posteriormente muestra en pantalla el texto tecleado.
/*

Descripción: Capt ura t ext o y el co nt enido lo guarda en arreglo
Fecha: 2-01-07
*/
import java.util.*;
public class Editor
{
{
String [ ]palabra= new String[100];
Scanner in = ne w Scanner(Sy ste m.in);
Syste m.out.println("Aplicacion que Captura Palabras");
Syste m.out.println(" Hasta Que Teclee salir");
for(int i=0;i<100;i++)
{
palabra[i]=in.nextLine();
if(palabra[i].equals("salir"))
break;
}
Syste m.out.println("\nEste su texto:\ n");
for(int cta=0;cta<100;cta++)
{
if(palabra[cta].equals("salir"))
break;
Syste m.out.println(palabra[cta]);
}
}
}
By: m @ gh 28

? Ejemplo 21, aplicación que almacena en un arreglo una lista de nombres. Posteriormente
los ordena a través del método de ordenación de la burbuja. Muestra en pantalla la lista de
los nombres ordenados en forma ascendente.
/*

Descripción: List a de no mbres almacenados en arreglo, post er ior ment e los ordena
a t ravés del Mét odo de Ordenació n de la Bur buja.
Fecha: 2-01-07
*/
import java.util.*;
public class OrdenaNombres
{
{
String no mbres[ ]={" Martin","Ana","Elsa","Alejandro","Diana", "Luis"};
Syste m.out.println("Aplicacion que Ordena los Nombres de la Lista.");
for(int j=0; j<no mbres.length; j++)
{
for(int i=j+1;i<no mbres.length;i++)
{
if(no mbres[i].co mpareTo(no mbr es[j])<0)
{
String au x= no mbres[ j];
no mbres[ j]= no mbres[i];
no mbres[i]= aux;
}
}
}
for(int cta=0;cta<no mbres.length;cta ++)

{
Syste m.out.println(nombres[cta]);
}
}
}
By: m @ gh 29

? Ejemplo 22, aplicación que almacena en un arreglo una lista de números. Posteriormente
los ordena a través del método de ordenación de la burbuja. Muestra en pantalla la lista de
los números ordenados en forma ascendente.
import java.util.*;
public class OrdenaNums
{
{
int total;
int num[ ]= ne w int[10];
Scanner in = ne w Scanner(Syste m.in);
do
{
Syste m.out.println("Cantidad de Nu meros a Capturar? ");
total=in.nextInt();
} while(total>10);
Syste m.out.println("Captura de Numeros");

for(int x=0; x<total; x++)
{
Syste m.out.print("Nu mero("+x+") :");
nu m[ x]=in.nextInt();
}
for(int j=0; j<total;j++)

{
for(int i=j+1;i<total;i++)
{
if(nu m[i]< nu m[ j])
{
int aux= nu m[ j];
nu m[ j]= nu m[i];
nu m[i]= au x;
}
}
}
Syste m.out.println("\n Lista de Nu meros Ordenados:");

for(int cta=0;cta<total;cta++)
{
Syste m.out.print("\t"+nu m[cta]);
}
}
}
By: m @ gh 30

INTRODUCCIÓN A LOS APPLETS
Los applets son aplicaciones gráficas que aparecen en una zona de la ventana del
navegador, dicho de otra forma es un programa basado en ventanas. Los applets son
conducidos u orientados a eventos. Un applet espera a que ocurra un evento. El AWT
(Abstract Windows Toolkit) notifica el evento al applet llamando a un gestor de eventos para
que lo trate. Después el applet debe ejecutar la acción que desee el programador y devolver
el control rápidamente al AWT. El usuario es el que debe iniciar una interacción con el applet.
Todos los applets son subclases de la clase applet, Cualquier applet debe importar los
paquetes java.applet y java.awt. Los applets son ejecutados por un navegador de internet o
bien por un visor de applets (appleetviewer), incluido en JDK. La ejecución de un applet no
comienza con el main(). Sino que es gestionada por varios métodos del AWT. Una vez que
se ha compilado un applet, se incluye en un archivo HTML utilizando la etiqueta applet.
Diferencias entre Aplicaciones y Applets

Aplicaciones Sencillas en Java Applets en Java
Permite desarrollar aplicaciones que se Permite desarrollar módulos descargables a
ejecutan en el intérprete local de JSDK, es través de una página web y ejecutable en la
decir desde la línea de comando. JVM del navegador.
No permiten interfaz grafica, ni manejo de Al ejecutarse desde un navegador, tiene la
eventos. ventaja de la estructura: una ventana, manejo
de eventos, gráficos e interfaz de usuario.
ESTRUCTURA DE UN APPLET
Casi todos los applets sobrescriben una serie de métodos que proporcionan el mecanismo
básico mediante el que el navegador o el visor de applets conecta con el applet y control su
ejecución. Cuatro de estos metodos son: init(), start(), stop(), destroy() los define el
applet. El paint() lo define la clase Component. Como se muestra en esta estructura:
import java.a wt.*; //

import java.applet.*; //
public class No mbre_applet extends Applet
{ public void init()
{// Código de inicialización}
public void start()
{// Código que co mienza o reanuda la ejecución }
public void stop()
{// Código que detiene la ejecución}
// Se ejecuta cuando termina el applet. Es el último método que se ejecuta
public void destroy()
{// Código para la finalización definitiva}
// Es llamado cuando se restaura la ventana del applet
public void paint(Graphics g)
{// Código para dibujar el contenido en la ventana}
}
By: m @ gh 31

? Ejemplo 23, diseñamos un applet que envie a la ventana un mensaje en las posiciones
especificadas (columna, renglón).
import java.applet.Applet;
import java.a wt.*;
public class HolaJava extends Applet
{
public void paint(Graphics g) // Inicia lizamos el mét odo Grafico
{
g.drawString("Mi 1er Applet",20,50); //Envia mo s un mensaje a la vent ana
// en las coordenadas: Co l, Reng
}
}
import java.awt.*;
En nuestro applets deberemos, incluir como mínimo estas dos sentencias de importación. En
la primera importamos la clase Applet, de la cual derivaremos nuestros applets. La segunda
permite importar las clases de la librería AWT, que nos permitirán dibujar en el rectángulo
asignado al applet.
public class HolaJava extends Applet {

}
Nuestros applet siempre van a ser clases derivadas de Applet, pues en esta clase y en sus
clases padre se definen los métodos que deberemos sobreescribir para que nuestros applets
respondan a los eventos generados desde el navegador.
public void paint(Graphics g) {

}
Este es el método que debemos sobreescribir para dibujar en el rectángulo asignado a
nuestro applet. Recibe un parámetro que es una referencia a una instancia de tipo Graphics.
Esta clase permite definir lo que se suele denominar lienzo (o Canvas). El lienzo es
precisamente ese rectángulo del que estamos hablando todo el rato.
g.drawString("Mi 1er Applet",20,50);

La clase Graphics dispone de muchos métodos para dibujar en el lienzo. Éste,
concretamente, nos permite dibujar un texto en la posición que queramos. En este caso el
texto se pintará 20 píxeles a la derecha del borde izquierdo de la pantalla y otros 50 píxeles
abajo del borde de superior.
Incrustar un Applet en una Pagina Web

La etiqueta applet se utiliza para arrancar un applet tanto desde un archivo HTML como
desde un visor de applets. Un visor de applets ejecutará cada etiqueta applet que encuentre
en una ventana independiente, mientras que navegadores como: Netscape Navigator,
Internet Explorer, HotaJava, Mozilla Firefox permiten ejecutar varios applets en una unica
pagina. La sintaxis para una etiqueta applet, lo que esta entre corchetes es opcional:
By: m @ gh 32

<applet [codebase=url] code=archivo Class [alt=texto_alternativo]
width=pixels heig ht=pixels [align=tipoAlineamiento]>
</applet>
codebase:
es un atributo opcional que especifica el URL del código del applet, que es el directorio
donde se buscará el archivo de clase ejecutable del applet.
code:
es un atributo necesario y proporciona el nombre del archivo que contiene el archivo
compilado .class del applet.
alt:
es un atributo opcional que especifica el mensaje que se debe visualizar en caso de que el
navegador entienda la etiqueta applet pero no pueda ejecutar applets Java. Este es diferente
al texto alternativo de HTML.
width y height:
son atributos necesarios que dan el tamaño del area de visualización de un applet (en
píxeles).
align:
es un atributo opcional que especifica la alineación del applet. Puede tomar los siguientes
valores: left, right, top, bottom, middle, baseline, texttop, absmiddle, absbottom.
Si desea incluir su applet en una página web. La página que desarrollaremos es la siguiente.
Puedes utilizar un editor de páginas web o cualquier editor de texto, para nuestro ejemplo
usaremos el Bloc de notas, haciendo clic en Inicio / Programas / Accesorios / Bloc de notas:
<HTML>
<BODY>
<APPL ET CODE="HolaJava.class" W IDTH="200" HEIGHT="70">
</APPL ET>
</BODY>
</HTML >
Cuando termines de teclear estas líneas de código, clic en Archivo / Guardar como. Del
cuadro de dialogo: en el cuadro Tipo: Todos lo archivos. Y en el cuadro Nombre: Hola.ht ml
Ahora ingresa al Explorador de Windows o MiPC, busca el archivo: Hola.html has doble clic
sobre este, se abre navegador con el contenido de esta pagina, para nuestro ejemplo, solo
se visualizará el mensaje: Mi 1er Applet
By: m @ gh 33

CLASE Graphics
La clase Graphics dispone de más métodos aparte de drawString, que nos permitirán dibujar
figuras e imágenes.
Métodos de dibujo
Mientras no se especifique, consideraremos que todos los parámetros son enteros:
drawStri ng(St ring texto,x,y)

Escribe un texto a partir de las coordenadas (x,y), que representan columna, fila.
drawLine(x1, y1,x2, y2)

Dibuja una línea entre las coordenadas (x1,y1) y (x2,y2).
drawRect(x,y,a nc ho,alto)
fillRect(x,y,a ncho,alto)
clearRect(x,y,a nc ho.alto)
Son tres métodos encargados de dibujar, rellenar y limpiar, respectivamente, un
rectángulo cuya esquina superior izquierda está en las coordenadas (x,y) y tienen el
ancho y alto especificados.
drawRoundRect(x,y,a nc ho,alto,anchoArco,altoArco)
fillRoundRect(x, y,a ncho,alto,anc ho Arco,altoArco)
Equivalentes a los anteriores, pero con las esquinas redondeadas. La forma y tamaño
de dichas esquinas viene dada por los dos últimos parámetros.
draw3DRect(x,y,a nc ho,alto,boolean elevado)

fill3DRect(x,y,a ncho,alto,boolean el evado)
Equivalentes a los primeros, pero dibujan un borde para dar la sensación de que está
elevado o hundido (dependiendo del valor del último parámetro).
drawOval(x, y,a nc ho,alto)

fillOval(x, y,a ncho,alto)
Dibujan una elipse con esquina izquierda superior en (x,y) y el ancho y alto
especificados. Si son iguales dibujará un círculo.
draw Arc(x, y,a ncho,alto,ang ulo Inicio, angulo Arco)

fillArc(x, y,anc ho,alto,anguloInicio,a ngulo Arco)
Dibuja una arco cuyo primer vértice está en (x,y) y el segundo en (x+ancho,y+alto). La
forma del mismo vendrá dado por los dos últimos parámetros.
drawPol ygon(int[ ] coordenadasX,i nt [ ] coordenadasY,numCoordenadas)

fillPolygon(i nt[ ] coordenadasX,i nt[ ] coordenadasY,numCoordenadas)
Dibuja un polígono cerrado del número de puntos especificado en el último parámetro.
copyArea(xO rigen, yO rigen,a nc ho,alto,xDest,yDest)

Copia el área cuya esquina superior izquierda está en (xOrigen,yOrigen) y de ancho y
alto especificados a la zona que comienza en (xDest, yDest).
By: m @ gh 34

? Ejemplo 24, diseñamos un applet que dibuje en la ventana: Líneas, Círculos y Cuadros
en las coordenadas y con los colores especificados. Después de 5 segs., vuelve a dibujar:
Círculos y Cuadros rellenados con los colores y en las coordenadas especificadas.
import java.a wt.*;
public class Figuras extends Applet
{
{
int i=1;
int gc=10,bc=150,rc=250;
for(i=1;i<=10;i++)
{
g.setColor(Color.yellow); //Est ablece co lor
g.drawLine(10, 10, 250, 10+i*10); //Dibuja líneas
g.setColor(Color.blue); //Est ablece co lor azul

g.drawRe ct(10+i*10, 10+i*10, 50+i*1 0, 50+i*10); //Dibuja cuadros
g.setColor(Color.black); //Est ablece co lor negro

g.drawOval(10+i*10, 10+i*10, 50+i*1 0, 50+i*10); //Dibuja círculos
} // fin del for
try // Inicia liza el Manejador de Errores con “t ry”

{ Thread.sleep(5000); //Ret arda el sigu ient e proceso por 5 seg.
}
// At rapa el error que se genere “cat ch”, si es necesar io muest ra el error.

catch(InterruptedException e)
{e.printStackTrace();
}
i=1;
g.setColor(Color.white); //Est ablece co lor blanco
g.fillRect(0, 0, 800, 600); //Dibuja un rect ángulo de co lor blanco
while(i<=10)
{
g.setColor(Color.blue); // Est ablece co lor azul
g.fillRect(10+i*10, 10+i*10, 50+i*10, 50+i*10); // Dibuja cuadros rellenado s
g.setColor(Color.black); // Est ablece co lor negro

g.fillOval(10+i*10, 10+i*10, 50+i*10, 50+i*10); //Dibuja cír culo s rellenado s
i++;
} // fin del while
} // fin paint
} // fin de class
By: m @ gh 35

Clase Color
Graphics almacena internamente el color con el que pinta todo, que por defecto es negro.
Para poder cambiar dicho color deberemos utilizar el método setColor(), que recibe un único
parámetro de tipo Color. Si desea establecer el color de fondo de una ventana de un applet
debe utilizar setBackground(). Pero si desea establecer el color de frente (color de texto,
lineas, etc) debe usar setForeground()
La clase Color dispone de varias propiedades estáticas que contienen los colores comunes:
Color Constante Valor RGB Color Constante Valor RGB
Naranja Orange 255,200,0 Gris gray 128,128,128
Rosa Pink 255,175,175 Gris claro light_gray 192,192,192
Cyan Cyan 0,255,255 Gris obs. dark_gray 64,64,64
Magenta magenta 255,0,255 Rojo red 255,0,0
Amarillo Yellow 255,255,0 Verde green 0,255,0
Negro Black 0,0,0 Azul blue 0,0,255
Blanco White 255,255,255
? Ejemplo 25, diseñamos un applet que dibuje en la ventana: Círculos. Y pueda crear
instancias de color por medio de constructores para definir colores menos comunes.
import java.a wt.*;
public class GrafCirculos extends Applet
{
{
int i=1;
int rc=255,gc=50,bc=10;
setBackground(Color.blue); // Est ablece co lor de fondo azul

for(i=1;i<=6;i++)
{
// Co lo ca el co lor co mbinado por RGB
g.setColor(new Color(rc,(gc*i)-45,(bc*i)+10));
// Dibu ja círculo s de co lores especificados por set Color

g.drawO val(110-i * 10, 110-i * 10, i * 20, i * 20);
} // fin del for
} // fin del paint
} // fin de class
By: m @ gh 36

CUADROS DE DIALOGO
La forma simple de entrada de datos en Java es similar a mostrar la salida de la ventana de
comandos con los métodos print o println del System.out tiene capacidades limitadas. Por
esta razón generalmente recibimos la entrada del usuario a través de un componente GUI
como un cuadro de dialogo de entrada.
El usuario puede escribir cualquier cosa en el espacio del cuadro de dialogo de entrada. Para
ello va a utilizar el método showInputDialog de la clase JOptionPane del paquete:
javax.swing.
Sintaxis:
variable_tipo_texto=JOptionPane.showInputDialog("texto a mostrar");
Eje mplos:
int numero;
nu mero=JOptionPane.sho wInputDialog("Introduce Nu mero:");
String nombre;
no mbre=JOptionPane.sho wInputDialog("Introduce No mbre:");
Si el usuario quiere mostrar resultados o valores a través de un cuadro de dialogo, debe

utilizar showMessageDialog de la clase JOptionPane del paquete javax.swing.
Sintaxis:
JOptionPane.showMessage Dialog(null, "texto a mostrar”,”titulo”,icono);
Eje mplos:
String nombre =”Martin Alejandro Guerr a Hernandez”;
JOpt io nP ane. showMessageDialog( nu ll, "Autor:"+no mbre, "Manual de Java2 ",
JOpt io nP ane.INFORMATION_MESSAGE);
int fecha=2007;
JOpt io nP ane. showMessageDialog( nu ll, "Año:"+fecha, "Curso de Java Básico ",
JOpt io nP ane.INFORMATION_MESSAGE);
Mensaje del Cuadro de Dialogo Icono Descripción

JOpt io nP ane.ERROR_MESS AGE Cuadro de dialogo que indica error al
usuario.
JOpt io nP ane.INFORMATION_MESSAGE Cuadro de dialogo con mensaje
informativo para el usuario.
JOpt io nP ane. WARNING_MESSAGE Cuadro de dialogo que advierte al
usuario un problema.
JOpt io nP ane.QUESTION_MESS AGE Cuadro de dialogo usado para que el
usuario responda.
JOpt io nP ane.P LAIN_MESS AGE Ninguno Cuadro de dialogo que solo tiene un
mensaje.
By: m @ gh 37

? Ejemplo 26, diseñamos un applet que capture la edad de 3 personas, utilizando cuadros
de dialogo. Debe calcular el promedio de edad. Debe visualizar el valor del promedio en un
cuadro de dialogo y en la ventana del applet.
import java x.swing.*;

import java.a wt.*;
public class Pro mDialogo extends Applet
{
int prom; // Var iable de Clase t ipo numér ica
public void init()
{
int su ma,edad;
int i=0;
String edads;
su ma=edad =pro m=0;
while(i<3)
{
// Muest ra un Cuadro de Dialogo, retorna un valor de t ipo t exto.
edads=JOptionPane.sho wInputDi alog("Introduce Edad ("+i+")");
// Co nviert e el t ext o a valor numér ico ent ero.

edad=Integer.parseInt(edads);
su ma =su ma+edad;
i++;
} // fin del while
pro m=su ma/i;
// Cuadro de Dialogo: con el t ext o y valo r del Pro medio, t it ulo, icono de Infor mació n
JOptionPane.sho wMessageDialog(null, "Promedio de Edad: "+pro m,
"Edad Pro medio",JOptionPane.INFORMATION MESSAGE);
} // Fin de Init

{
g.setColor(Color.blue); // Est ablece el co lor azul
g.drawLine(15,10,200,10); // Dibuja Línea
// Visua liza mensa je most rando el result ado de la var iable clase
g.drawString("Pro medio de Edad"+p ro m,25,25);
} // fin del paint
} // fin de class
By: m @ gh 38

MANEJO DE IMÁGENES
Aún cuando podemos hacer cosas vistosas con figuras, no estaría de más poder hacer cosas
con imágenes, que son bastante más espectaculares. Para hacerlo utilizaremos el método:
drawImage( Image img,int x,int y,ImageObserver observador )
Vemos que necesitamos un objeto Image y otro ImageObserver y de esas cosas no sabemos
todavía... No vamos a ver estos objetos muy a fondo. ImageObserver es un interfaz (que un
antepasado de Applet implementa) que nos ofrece información sobre la imagen según la
imagen se carga de la red. Por otro lado, Image es un objeto que representa a la imagen.
Normalmente crearemos un objeto Image por medio del método de Applet getImage():
Image img = getImage(URL base, String archivo)
Asigna la imagen contenida en la URL donde se encuentre el archivo que contiene la imagen
que queremos presentar y el nombre de ese archivo.
Normalmente obtendremos esa dirección a partir de la página donde esté la página HTML o
nuestro applet. Para averiguarlo disponemos de dos métodos en la clase Applet:
URL getDocumentBase()
Devuelve la URL donde está la página HTML (excluyendo el nombre del fichero).
URL getCodeBase()
Devuelve la URL donde está el applet (excluyendo el nombre del archivo). Si deseamos
obtener una URL distinta deberemos importar esa clase (java.net.URL) y crear uno
pasándole una cadena como parámetro al constructor conteniendo la URL.
Normalmente, se realiza el getImage() en el método init() del applet, ya que en el momento

en que ejecutemos este método comenzará la carga de imágenes desde Internet y eso
conviene hacerlo cuanto antes. Para mostrar la imagen se utiliza el método paint(), al igual
que hemos hecho para pintar cosas. Por ejemplo, incrustaremos la foto de Anette:
? Ejemplo 27, diseñamos un applet que visualiza la fotografía de una persona.

import java.a wt.*;
public class Foto extends Applet
{
I mage i mg; // Cr eamo s el o bjet o img de t ipo I magen
{
// Carga la imagen de la posic ió n especificada, escr iba no mbre de l archivo
img = getI mage(getDocu mentBase (), "Anette. jpg");
//Visualiza la imagen dentro del applet, en la posición especificada, referenciando al objeto actual.
g.drawI mage(i mg,100,100,this);
}
}
By: m @ gh 39

HERRAMIENTAS GRAFICAS DE AWT
Los controles son componentes que permiten al usuario interactuar con la aplicación de
varias maneras. Un gestor de organización posiciona automáticamente los componentes
dentro de un contenedor. Por tanto, la apariencia de una ventana viene determinada por la
combinación de controles que esta contiene y por el gestor de organización utilizada para
colocarlos.
AWT soporta los siguientes tipos de controles: Label (etiquetas), Button (botones), Checkbox
(casillas de verificación), List (lista desplegable) Scrollbar (barras de desplazamiento) y las
siguientes subclases: TextField (cajas de texto) y TextArea (área de texto).
Añadir y Eliminar Controles

Para incluir un control en la ventana es necesario añadirlo a la ventana. Para hacerlo,
primero hay que crear una instancia del control deseado y después añadirlo a la ventana
llamando a add(), que esta definido en la clase Container. Una vez que se ha añadido el
control, será visible en la ventana. Debe utilizar el método add, su sintaxis:
Co mponent add(Co mponent co mpOb j)
Donde: Component, se refiere a: frames, dialogs, panels, por defecto es windows.

add, agrega el control deseado al componente indicado.
compObj, se refiere es una instancia al control que se quiere añadir.
Algunas veces, cuando ya no necesita utilizar más el control, puede eliminarlo de la ventana.
Para hacerlo, debe utilizar remove() que esta definido en la clase Container. Su sintaxis:
void remove(Co mponent ob j)
Donde: remove, elimina el control deseado del componente indicado.

Component, se refiere a: frames, dialogs, panels, por defecto es windows.
Obj, es una referencia al control que se quiere eliminar.
Puede eliminar a todos los controles utilizando removeAll().
Control Label (etiquetas)

Una etiqueta es un objeto y contiene una cadena que muestra en la ventana. Las etiquetas
son controles pasivos que admiten interacción con el usuario. Label define los siguientes
constructores:
Label(“cadena”);
Label(“cadena”, int how);
La primera crea una etiqueta que contiene la cadena especificada. La segunda crea una
etiqueta que contiene la cadena especificada, alineando el texto en la posición indicada
(LEFT, RIGHT, CENTER)
Ejemplo: // Creació n de dos et iquet as

Label uno = new Label("1 uno");
Label dos = new Label("2 dos",Label.CENTER);
// Agrega las dos et iquet as cr eadas a la vent ana
add(uno);
add(dos);
By: m @ gh 40

Clase TextField (cajas de texto)
Implementa una area de entrada de texto de una sola linea que se llama control de edición.
Los campos de texto (textfield) permiten al usuario introducir texto y la edición de texto
utilizando los cursores y las teclas. El textfield es una subclase de TextComponent. Define
los siguientes constructores:
TextField (int numchars)
TextField (String str)
TextField (String str, int numchars)
El primer formato crea un campo de texto con el tamaño especificado en numchars. El
segundo campo de texto inicializa el campo de texto con el string dado por str. El tercero
inicializa el campo de texto con el string str y además especifica su tamaño.
Ejemplo: // Creació n de dos cajas de t ext o

uno = ne w TextField(10);
tres = ne w Te xtField("1 uno", 10);
// Agrega las dos cajas de t ext o creadas a la vent ana
add(uno);
add(tres);
// Se regist ra para recibir lo s event os de acció n que se generen en las do s
// cajas de t ext o
uno.addActionListener(this);
tres.addActionListener(this);
Control Button (botones)

Es un componente que contiene una etiqueta y que genera un evento cuando es pulsado.
Los botones son objetos de la clase button. Proporciona dos contructores:
Button ()
Button (String str)
El primero de ellos crea un botón vacío (sin etiqueta). El segundo crea un boton que contiene
str como nombre de etiqueta.
Ejemplo: // Creació n de dos boto nes

s = ne w Button();
n = ne w Button ("no");
// Agrega lo s dos bot o nes creados a la vent ana
add(s);
add(n);
// Define un método para recibir los eventos que se generen en los
// botones
s.addActionListener(this);
n.addActionListener(this);
Control Checkbox (casillas de verificación)

Es un control que se utiliza para activar o desactivar una opción. Está formado por un
pequeño cuadro que puede contener o no una marca de comprobación. Hay una etiqueta
asociada a cada Checkbox que describe que opción representa. Para cambiar el estado de
un Checkbox solo hay que pulsar sobre él. Los Checkbox se pueden utilizar individualmente
o como parte de una grupo, de acuerdo a los siguientes constructores:
By: m @ gh 41

Checkbox (String str);
Checkbox (String str, bolean on);
Checkbox (String str, CheckboGroup cbgroup, Boolean on);
El primer formato crea un Checkbox cuya etiqueta está especificada en str y el estado del
Checkbox aparece como no seleccionado. El segundo formato permite establecer el formato
inicial del Checkbox, si on es true, el Checkbox está inicialmente seleccionado. El tercer
formato crea un Checkbox cuya etiqueta viene especificada por str y cuyo grupo está
especificado por cbgroup, si este Checkbox no pertenece a ningún grupo debe ser nulo.
Ejemplo: // Creació n de dos casillas de ver ificacio n

aficion = new Checkbox (“Deportista”, null, true);
alimentos = ne w Checkbox ("Fruta");
// Agrega lo s dos casillas de ver ificació n creadas a la vent ana
add(aficion);
add(alimentos);
// Define un método para recibir los eventos que se generen en las
// casillas de verificación.
aficion.addItemListener(this);
alimentos.addIte mListener(this);
Control List (lista deplegable)

Este control proporciona una lista de selección compacta con desplazamiento que permite
realizar la selección del elemento o los elementos especificados. List tiene los siguientes
constructores:
List (int numrows);
List (int numrows, Boolean, multipleselect);
La primer versión, el valor numrows especifica el número de elementos que puede contener
la lista. En el segundo formato numrows especifica el número de elementos que puede
contener la lista y si multipleselect es true el usuario puede seleccionar dos o mas elementos
a la vez, en caso de ser false solo puede seleccionar un elemento.
Ejemplo: // Creació n de dos list as desplegables

colores = new List (3, true);
nu meros = ne w List (3);
// Agrega t res element os a la list a de co lores
colores.add(“azul”);
colores.add(“amarillo”);
colores.add(“rojo”);
// Agrega t res element os a la list a de numeros
nu meros.add(“uno”);
nu meros.add (“dos”);
// Se añaden las list as creadas a la vent ana
add(colores);
add (nu meros);
// Define un método para recibir los eventos que se generen en las
// listas.
colores.addActionListener(this);
numeros.addActionListener(this);
By: m @ gh 42

Control Scrollbar (barras de desplazamiento)
Este control se utiliza para seleccionar valores continuos entre un mínimo y un máximo
especificados. Las barras de desplazamiento puedes ser horizontales o verticales. Una barra
de desplazamiento puede tener varios elementos. Cada extremo tuene una flecha en la que
puede hacer clic para mover una unidad en la dirección de la flecha el valor actual de la barra
de desplazamiento. El valor actual de la barra de desplazamiento, en relación a sus valores
mínimo y máximo lo indica un cuadro o caja de deslizamiento, que el usuario puede arrastrar
hasta una nueva posición. La clase Scrollbar define los siguientes constructores:
Scrollbar (int style);
Scrollbar (int style, int initialvalue, int tamaño, int min, int max);
El primer formato permite crear una barra de desplazamiento, style define si es vertical u
horizontal. El segundo formato permite crear una barra de desplazamiento, style define si es
vertical u horizontal, el valor inicial de la barra se pasa son initialvalue, el numero de
unidades que representa la altura del cuadro es tamaño, los valores minimo y maximo de los
elementos se especifican con min, max.
Ejemplo: // Creació n de dos barras de desplazamiento
vertical = new Scrollbar (Scrollbar.VERTICAL, 0, 1, 0, height);
horizontal = new Scrollbar (Scrollbar.HORIZONTAL, 0, 1, 0, width);
// Agrega las dos barras de desplazamient o a la vent ana
add(vertical);
add(horizontal);
// Define un método para recibir los eventos de aju ste en las barras
// de desplazamiento.
vertical.addAdjusmentListener(this);
horizontal.addAdjusmentListener (this);
By: m @ gh 43

? Ejemplo 28, diseñamos un applet que visualice la edad de la persona, permitiendo al
usuario modificarla a traves del Control Srcollbar.
import java.a wt.*;
import java.a wt.event. *;
public class MenorMayorEdad e xtends Applet imple ments Ad just mentListener

{
private Scrollbar barra;
private int edad = 0;
public void init()
{
barra = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, 100);
add(barra);
barra.addAdjust mentListener(this);
}
{
if (edad > 17)
{
g.drawString ("eres mayor de edad", 5 0, 50);
g.drawString("Tu edad es " + edad, 50, 70);
}
else
{
g.drawString ("eres menor de edad ", 5 0, 50);
}
}
public void adjust ment ValueChanged(Ad just mentEvent e vent)
{
edad = barra.getValue();
repaint();
}
}
By: m @ gh 44

? Ejemplo 29, diseñamos un applet que permite al usuario conocer el numero de veces que
ha presionado el boton.
import java.applet.*;
import java.a wt.*;
public class ContarPulsaciones extends Applet imple ments ActionListener

{
private Button contador;
private int cuenta = 0;
public void init()
{
contador = ne w Button("Opri ma aquí");
add(contador);
contador.addActionListener(this);
}
public void actionPerformed(ActionEvent event)
{
cuenta++;
repaint();
}
{
g.drawString("Ocasiones que ha presionado el boton: " + cuenta, 10, 50);
}
}
By: m @ gh 45

? Ejemplo 30, diseñamos un applet que permite al usuario teclear la edad de una persona.
El applet indicara que tipo de edad tiene.
import java.applet.*;
import java.a wt.*;
public class VerificaEdad extends Applet
imple ments ActionListener
{
private TextField edadCampo;
private int edad;
public void init()
{
edadCa mpo=ne w Te xtField(10);
add(edadCa mpo);
edadCa mpo.addActionListener(this);
}
public void actionPerformed(ActionEvent event)
{
edad=Integer.parseInt(edadCa mpo.get Text());
repaint();
}
public void paint (Graphics g)
{
if (edad >30)
g.drawString("Eres un Adulto", 50,100);
else if (edad >20)
g.drawString("Eres un Joven", 50,100);
else if (edad >10)
g.drawString("Eres un Jovencito", 50, 100);
else
g.drawString("Eres un Niño", 50,100);
}
}
By: m @ gh 46

REFERENCIAS BIBLIOGRAFICAS:
Programación en Java 2
Luis Joyanes Aguilar / Ignacio Zahonero Martinez
McGrawHill
1era. Edición. 2002
Manual de Referencia de Java 2

Herbert Schildt
Osborne-McGrawHill
4ta. Edición. 2001
REFERENCIAS WEBGRAFICAS:
http://www.lawebdelprogramador.com/cursos/
http://www.progra ma cion.co m/ java/tuto riales/J2SE/
http://www.elguruprogra mador.com. ar/
http://www.desarrolloweb.co m/ manuales/57/
SOFTWARE UTILIZADO:
http://ja va.sun.co m/ j2se/1.5.0/do wnloa d.jsp
http://www.jgrasp.org
By: m @ gh 47

Java

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Java

Cargado por

Copyright:

Formatos disponibles

Aprenda Java

By: Martín Alejandro Guerra Hernández

Jiquilpan, Michoacán. Enero del 2007

PDF created with pdfFactory Pro trial version www.pdffactory.com

Breve Historia de Java …………………………………………………………………… 1

PDF created with pdfFactory Pro trial version www.pdffactory.com

Como lenguaje de programación para computadores, Java se introdujo a finales de 1995. La

Al programar en Java no se parte de cero. Cualquier aplicación que se desarrolle “cuelga” (o

PDF created with pdfFactory Pro trial version www.pdffactory.com

EL ENTORNO DE DESARROLLO DE JAVA

El compilador de Java, es de una de las herramientas de desarrollo incluidas en el JDK.

La Java Virtual Machine, se planteó la necesidad de conseguir un código capaz de

Las variables PATH y CLASSPATH, el desarrollo y ejecución de aplicaciones en Java

PDF created with pdfFactory Pro trial version www.pdffactory.com

La Clase, es una agrupación de datos (variables o campos) y de funciones (métodos) que

Clase Objeto Estado Comportamiento

La Programación Orientada a Objetos se basa en la programación de clases. Un programa

En Java, las clases soportan 3 características fundamentales de la POO: encapsulación,

PDF created with pdfFactory Pro trial version www.pdffactory.com

2. Variables locales: Se definen dentro de un método o más en general dentro de cualquier

Abstract Boolean Break byte case Match

Tipos Primitivos de Variables

Tipo de variable Descripción

PDF created with pdfFactory Pro trial version www.pdffactory.com

Cómo se definen e inicializan las variables

Ejemplos de declaración e inicialización de variables:

VISIBILIDAD Y VIDA DE LAS VARIABLES

PDF created with pdfFactory Pro trial version www.pdffactory.com

Visibilidad de las variables de una clase de menos accesible a más:

Uno de los aspectos más importantes en la programación orientada a objetos (OOP) es la

PDF created with pdfFactory Pro trial version www.pdffactory.com

PDF created with pdfFactory Pro trial version www.pdffactory.com

Operador Nombre Utilización Resultado

Operador de concatenación de cadenas de caracteres (+)

PDF created with pdfFactory Pro trial version www.pdffactory.com

Ent rada (System.i n)

Paquete io (import java.io.*;)

PDF created with pdfFactory Pro trial version www.pdffactory.com

ESTRUCTURA DE UN PROGRAMA EN JAVA

import no mbrePaquete.no mbreClase; // Importación de las clases de los paquetes.

? Ejemplo 1, consiste en enviar un mensaje a la pantalla:

PDF created with pdfFactory Pro trial version www.pdffactory.com

? Ejemplo 3, consiste en declarar variables de texto y numéricas, asignarles valores e

? Ejemplo 4, consiste en declarar variables numéricas, asignarles valores. Calcular la

PDF created with pdfFactory Pro trial version www.pdffactory.com

import java.io.*; // Importación de la clase io de entrada/salida

// Definida en la clase System, cuya referencia esta dada en el in .

System.out.println("Nombre"); //Muestra en pantalla el mensaje Nombre

// Muestra en pantalla el nombre, la edad y el total de segundos de vida de la persona.

PDF created with pdfFactory Pro trial version www.pdffactory.com

import java.util.*; // Importación de la clase ut il de entrada/salida

// Declaración de variables locales tipo flotante que almacenará 2 de las calificaciones.

// Declaración de variables locales tipo double que almacenará 1 calificación y el promedio

// Creamos una clase in de tipo Scanner (del paquete java.util)

Syste m.out.print("No mbre:"); //Muestra en pantalla el mensaje Nombre

// Realiza el calculo del promedio y el resultado se lo asigna a la variable prom

// Muestra en pantalla el dia, el promedio y en otra linea el nombre del alumno(a)

PDF created with pdfFactory Pro trial version www.pdffactory.com

Estas permiten controlar el comportamiento de un método o de un programa. Las estructuras

Otro formato de la sentencia if es la sentencia if-else. El formato tiene la siguiente sintaxis:

? Ejemplo 7, consiste en capturar la edad de la persona. Debe distinguir si esa persona

Scanner in = new Scanner(Syste m.in);

PDF created with pdfFactory Pro trial version www.pdffactory.com

Autor: Mart ín Ale jandro Guerra Hernández / m@gh