COMO PROGRAMAR EN JAVA para Estudiantes PDF

Folleto elaborado por: MSc.
Janine Mairena Solorzano
COMO PROGRAMAR EN JAVA
Unidad I: Introducción
 Historia de Java
 Biblioteca de clases de Java
 Fundamentos de un entorno Java típico
 Introducción a la programación en Java
1.1 Historia de Java
Sun Microsystems reconociendo que los microprocesadores tendrán un impacto profundo en

los dispositivos electrónicos de consumo inteligente financio un proyecto un proyecto de
investigación corporativo interno con el nombre en código Green en 1991. un resultado del
proyecto fue la creación de un lenguaje basado en C y C++ que su creador, James Gosling,
llamo Oak, inspirado por un roble (oak, en ingles) que crecía afuera de su ventana en Sun.
Mas tarde se descubrió que ya existía un lenguaje de programación llamado Oak. Cuando un
grupo de empleados de Sun visito una cafetería local, alguien sugirió el nombre Java (como se
conoce también en ingles al café), y el nombre pego.
No obstante el proyecto Green se vio en problemas. El mercado para dispositivos electrónicos

de consumo inteligente no estaba creciendo con la rapidez que Sun había anticipado. Peor aun,
un contrato importante por el que Sun estaba concursando fue otorgado a otra compañía. El
proyecto estaba en peligro de ser cancelado. En una afortunada coincidencia, la popularidad de
la World Wide Web hizo explosionen 1993 y la gente de Sun detecto el potencial inmediato
de Java para la creación de paginas de Web con “contenido dinámico”.
Sun anuncio formalmente Java en una conferencia importante en mayo de 1995.

Ordinariamente, un evento de tal naturaleza no habría generado tanta atención. Sin embargo
Java hizo surgir un interés inmediato en la comunidad de los negocios en vista de la magnitud
del interés comercial por la Web. Java no era un lenguaje académico como Pascal o un
lenguaje diseñado por una sola persona o grupo reducido para su propio uso local como C o
C++, Java había sido diseñado con motivos comerciales y genero un interés avasallador en la
comunidad de los negocios a causa de otro avance relacionado con la Internet, La World Wide
Web.
1.2 Biblioteca de clases de Java
Los programas en Java consisten en piezas llamadas clases y métodos. Podemos programar
cada pieza que vayamos a necesitar para formar un programa java, pero la mayoría de los
programadores que usan Java aprovechan las ricas colecciones de clase y métodos que existen
ya en las bibliotecas de clases de Java. El aprendizaje de java consiste en: Primero: aprender el
lenguaje para poder programar clases y métodos propios y el segundo aprender a usar las
clases y métodos de las extensas bibliotecas de clases de Java.
1
Folleto elaborado por: MSc. Janine Mairena Solorzano
La ventaja de crear clase y métodos propios es que se conoce con exactitud su funcionamiento
y es posible examinar el código Java. La desventaja es el tiempo y el esfuerzo que hay que
invertir en el diseño y desarrollo de clases y métodos nuevos.
El empleo de clases y métodos de biblioteca en lugar de versiones propias puede mejora el

rendimiento de los programas por que tales clases y métodos se han escrito cuidadosamente
con el fin de que función eficientemente, además de mejorar la transportabilidad de los
programas porque dichas clases y métodos se incluyen en prácticamente todas las
implementaciones de Java.
1.3 Fundamentos de un entorno Java típico
Los sistemas Java generalmente constan de varias partes:

 Un entorno
 El lenguaje
 La interfaz de programación de aplicaciones (API, Applications Programming
Interface) de Java y diversas bibliotecas de clases.
Los programas Java normalmente pasan por cinco fases antes de ejecutarse Fig. (1.1). Estas
son:
1. EDITAR
2. COMPILAR
3. CARGAR
4. VERIFICAR
5. EJECUTAR
La fase 1 consiste en editar un archivo. Esto se hace con un programa editor, almacenándolo
en un dispositivo de almacenamiento secundario como un disco. Los nombres de archivo de
los programa en Java terminan con extensión .java. dos editores que se utilizan mucho en los
sistemas UNÍS son vi y emacs. En Windows 95 y NT son suficientes programas de edición
sencillos como el comando EDIT del DOS y el programa Notepad de Windows.
En la fase 2, el programador emite el comando javac para compilar el programa. El

compilador de java traduce el programa java a códigos de bytes, que es el lenguaje que
entiende el interprete de Java. Si se desea compilar un programa llamado Welcome.java
teclee:
javac Welcome.java
Si el programa se compila correctamente, se producirá un archivo llamado Welcome.class

siendo este el archivo que contiene los códigos de bytes que serán interpretados durante la fase
de ejecución.
2
La fase 3 se llama carga. Antes de que el programa pueda ejecutarse, es necesario colocarlo
en la memoria. Esto lo hace un cargador de clases que toma el archivo (o archivos) .class que
contiene los códigos de bytes y los transfiere a la memoria. El archivo .class puede cargarse de
un disco de su sistema o a través de una red.
El cargador de clases comienza a cargar archivos .class en dos situaciones. Por ejemplo, el
comando:
java Welcome
invoca el interprete java para el programa Welcome y hace que el cargador de clases cargue la
información empleada en el programa Welcome. Llamamos al programa Welcome una
aplicación. Las aplicaciones son programas que son ejecutados por el interprete de Java. El
cargador de clases también se ejecuta cuando una applet de Java se carga en un navegador de
la WWW, como Navigator de Netscape o HotJava de Sun.
Las applets (la terminación “let” en ingles denota un diminutivo, por lo que el termino applet
significa “aplicacioncita”) son programas de Java que normalmente se cargan de la Internet
mediante un navegador. Se cargan cuando el usuario curiosea un documento en HTML
(Hypertext Markup Language: Lenguaje de marcado de hipertexto) que contiene a la applet.
también pueden ejecutarse desde la línea de comando utilizando el comando appletviewer
incluido en Java Developer’s Kit (JDK): un conjunto de herramientas que incluye al
compilador (javac), al interprete (java), a appletviewer y a otras herramientas empleadas por
los programadores de Java.
Al igual que Nestcape Navegator y HotJava, appletviewer requiere de un documento HTML

para invocar una applet. Por ejemplo si el archivo Welcome.html hace referencia a la applet
Welcome, el comando appletviewer se usa así:
Appletviewer Welcome.html
Esto hace que el cargador de clases cargue la información utilizada en la applet Welcome.
Appletviewer es como el navegador o browser mínimo, pues solo sabe como interpretar las
applets.
Antes de que el interprete o appletviewer pueda ejecutar los códigos de bytes, estos son
verificados por el verificador de códigos de bytes en la fase 4. Esto asegura que los códigos
de bytes son validos y que no violan las restricciones de seguridad de Java. Ya que los
programas Java que llegan por la red podrían causar daños a los archivos y al sistema de
usuario.
En la fase 5 la computadora controlada por el CPU, interpreta el programa un código de byte

a la vez.
3
Fig 1.1 Un entorno de Java típico
Editor Disco El programa se crea en el editor y se

Almacena en el disco.
El compilador crea códigos de bytes y los

Compilador Disco almacena en disco.
Memoria primaria
Cargador de
clases
El cargador de clases coloca código de
Bytes en la memoria.
Disco
Memoria primaria
Verificador de
códigos de bytes
El verificador de códigos de bytes
Confirma que todos los códigos sean
Validos y que no se violen las restricciones
De seguridad de Java.
Memoria primaria
Interprete
El interprete lee códigos de bytes y los
traduce a un lenguaje que la computadora
pueda entender, tal vez almacenando
valores de datos conforme los ejecuta el
programa.
4
Unidad II: Introducción a las aplicaciones en Java
Una aplicación en java es un programa que se ejecuta utilizando el interprete de java. Todo
programa en java consiste de cuando menos, una declaración de clase, que el programador
debe definir y se conocen como clase definida por el programador o por el usuario debe ser
una declaración publica de una clase, al nombre de la clase se le conoce como identificador y
debe comenzar con letra mayúscula y puede contener letras, dígitos, subrayado ( _ ) y signos
de moneda ( $ ) y no puede tener espacios en blanco, Kava es sensible a mayúsculas y
minúsculas. Esta clase debe ser declarada de tipo publica. Cuando se guarda su declaración de
clase public en un archivo, el nombre de este debe ser el nombre de la clase seguido de la
extensión .java
Una llave izquierda { comienza el cuerpo de la declaración de una clase y una llave derecha }
termina la declaración de una clase.
Toda aplicación en Java comienza con el método main los paréntesis después del main indican
que este es un bloque de construcción del programa, al cual se le llama método. Las
declaraciones de clases generalmente contienen uno o mas métodos, en una aplicación solo
uno de los métodos debe llamarse main. Las llaves { } definen el cuerpo de la declaración del
método.
Ejm:
// Bienvenido.java
// Programa para imprimir texto.
public class Bienvenido {
// el método main empieza la ejecución de la aplicación en Java

public static void main( String args[] )
{
System.out.println( "Bienvenido a la programación en Java!" );
System.out se conoce como el objeto de salida estándar, permite a las aplicaciones mostrar
conjunto de caracteres en la ventana de comando, desde la cual se ejecuta la aplicación en
Java.
// Bienvenido1.java
// Imprime una línea de texto con varias instrucciones
public class Bienvenido1 {

{
System.out.print( "Bienvenidos a " );
System.out.println( "la programación en Java!" );
}
}
5
// Bienvenido2.java
// Imprime varias lineas de texto en una sola instruccion.

{
System.out.println( "Bienvenidos\na\nla Programación\nen Java!" );
Como mostrar texto en un cuadro de dialogo.
La clase JOptionPane de Java proporciona cuadros de diálogos previamente empaquetados,

los cuales permiten a los programas mostrar ventanas que contengan mensajes para los
usuarios, en vez de mostrarlos en la ventana de comando. Ejm:
// Imprimir varias líneas de texto en un cuadro de dialogo
// Paquetes de Java
import javax.swing.JOptionPane; /* El programa usa clase JoptionPane del paquete
javax.swing */
public static void main ( String args[] )

{
JOptionPane.showMessageDialog (
null, “ Bienvenido\na\nla programacion\nen Java” );
System.exit( 0 ); //terminar la aplicación con la ventana
}
}
El paquete javax.swing contiene muchas clases que ayudan a los programadores en Java a
crear Interfaces Graficas de Usuario (GUI) para las aplicaciones.
El método showMessageDialog de la clase JOptionPane muestra un cuadro de dialogo para

mandar el mensaje. Este método requiere dos argumentos, por el momento el primero será
null y el segundo el mensaje. El primer argumento ayuda a la aplicación den Java a determinar
en donde se va a colocar el cuadro de dialogo, cuando es null aparece en el centro de la
pantalla.
System.exit(0); Se requiere para terminar cualquier aplicación que muestre una interfaz
grafica de usuario. (La clase siempre va en letra mayúscula, el método no). La clase System es
6
parte del paquete java.lang, que no fue importada en el programa, ya que se importa en todos
los programas de manera predeterminada, siendo el único paquete que no requiere una
declaración import. El argumento ( 0 ) indica que el programa termino correctamente(un valor
distinto indica error).
Ejm 2: Suma de enteros
// Programa que muestra la suma de dos números
// Paquetes de Java
import javax.swing.JOption.Pane;
public class Suma{
// el método empieza la ejecución de la aplicación en Java

{
String pNumero; // primera cadena introducida por el usuario
String sNumero; // segunda cadena introducida por el usuario
int n1; // primer numero a sumar

int n2; // segundo numero a sumar
int suma;
// leer el primer numero como una cadena

pNumero = JOption.Pane .showInputDialog ( “Escriba el primer entero” );
// leer el segundo numero

sNumero = JOption.Pane .showInputDialog ( “Escriba el segundo entero” );
// Convertir los números de tipo String a tipo int

n1=Integer.parseInt( pNumero );
n2=Integer.parseInt( sNumero );
// Sumar los números

suma = n1 + n2;
// mostrar el resultado
JOptionPane.showMessageDialog ( null, “La suma es “ + suma,
“Resultados”, JOptionPane.PLAIN_MESSAGE );
System.exit( 0 );
} // Fin del método main

} // Fin de la clase suma
7
El tercer argumento de JOptionPane.showMessageDialog “Resultados” se coloca en la

barra de titulo del cuadro de dialogo. JOptionPane.PLAIN_MESSAGE es el tipo de cuadro
de dialogo. Los tipos de cuadros de diálogos se muestran a continuación:
Tipo de cuadro de dialogo de mensaje Icono Descripción

JOptionPane.ERROR_MESSAGE Muestra un cuadro de dialogo que indica
un error al usuario
JOptionPane.INFORMATION_MESSAGE Muestra un cuadro de dialogo con un
mensaje informativo para el usuario. Este
puede simplemente descartar el cuadro de
dialogo.
JOptionPane.WARNING_MESSAGE Muestra un cuadro de dialogo que advierte
al usuario de un problema potencial
JOptionPane.QUESTION_MESSAGE Muestra un cuadro de dialogo con un signo
de interrogación para el usuario. Este
cuadro de dialogo generalmente requiere
una respuesta, como hacer clic en un botón
SI o NO
JOptionPane.PLAIN_MESSAGE Muestra un cuadro de dialogo que
simplemente contiene un mensaje,
sin icono.
8
1.5 Introducción a la programación en Java
El lenguaje Java facilita un enfoque disciplinado del diseño de programas para computadora.
Comenzaremos por considerar un applet sencilla que exhibe una línea de texto
1 //Un primer programa en Java

2 import java.applet.Applet; //importar la clase Applet
3 import java.awt.Graphics; //importar la clase Graphics
4
5 public class Welcome extends Applet {
6 public void paint(Graphics g)
7 {
8 g.drawString( "Bienvenidos a la programación en JAVA", 25, 25 );
9 }
10 }
Cuando guardamos una applet en un archivo, usamos el nombre de clase de la applet como
parte del nombre de archivo. En nuestro caso, el nombre del archivo seria: Welcome.java
1 // indica que el resto de la línea es un comentario.
2 Java contiene muchos componente predefinidos llamados clases que se agrupan

mediante directorios de disco en categorías de clases relacionadas entre si llamadas
paquetes. Llamamos a los paquetes bibliotecas de clase de java o interfaz de
programación de aplicaciones de Java (Java API). Las líneas:

son enunciados import, que cargan las clases necesaria para compilar un programa de
Java. Estas líneas le dicen al compilador que debe cargar la clase Applet del paquete
java.applet y la clase Graphics del paquete java.awt. Para crear una applet en java es
necesario importar la clase Applet. Importamos la clase Graphics para que el
programa pueda exhibir información en la pantalla.
3 La línea
public class Welcome extends Applet {
inicia una definición class de applet para la clase Welcome. La palabra clave class
(clase) introduce una definición de clase en java y va seguida inmediatamente por el
nombre de la clase (Welcome). Todo programa en java debe tener por lo menos una
definición de clase. Cuando creamos una definición de clase, siempre utilizamos partes
de una definición de clase ya existente. Java proporciona un mecanismo llamado
herencia para crear clases nuevas que utilizan parte de definiciones de clase ya
existentes. La palabra clave extends (extiende) seguida de un nombre de clase indica
9
la clase de la cual nuestra nueva clase heredara algunas partes. Todas la applets de
java deben heredar de la clase Applet, en la relación de herencia Applet es la
superclase o clase base y Welcome es la subclase o clase derivada.
Las clases sirven para ejemplarizar ( o crear) objetos en la memoria que se usaran en
un programa. Un objeto es una región de la memoria de la computadora en la que se
almacena información para ser utilizada por el programa. Nuestra clase Welcome sirve
para crear un objeto que ejecuta la applet. El navegador en el que ejecutamos la applet
es el que se encarga realmente de crear un ejemplar de la clase Welcome para
nosotros.
La palabra clave public (publica) permite al navegador crear y ejecutar nuestra applet.
En Java la clase principal de applets ( la que hereda de Applet) siempre es una clase
publica.
La llave izquierda { inicia el cuerpo de toda definición de clase. Una llave derecha }
correspondiente debe terminar toda definición de clase.
4 La línea
public void paint(Graphics g)
Introduce un bloque de construcción de programa llamado método. Los programas java

contienen por lo menos un método que realiza tareas durante la ejecución de la applet.
Este programa contiene el método paint (pintar) el cual es invocado automáticamente
durante la ejecución de la applet y sirve para exhibir información en la pantalla. Los
métodos pueden realizar tareas y devolver información cuando completan sus tareas.
La palabra clave void (vació) indica que este método realiza una tarea, pero que no
devuelve ninguna información al terminarla. El juego de paréntesis después de paint
define la lista de parámetros del método. La lista de parámetros sirve para que el
método reciba la información que necesita para llevar a cabo sus tareas. La lista de
parámetros indica que requiere un objeto Graphics (que se llama g) para realizar su
tarea. La palabra clave public es necesaria para que el navegador pueda invocar
automáticamente el método paint.
La llave { inicia el cuerpo de la definición del método. La llave } debe terminar el

método. La línea:
g.drawString( "Bienvenidos a la programación en JAVA", 25, 25 );
Ordena a la computadora realizar una acción, a saber, usar el método drawString

(dibujar cadena) del objeto Graphics g para dibujar la cadena de caracteres contenida
entre el par de comillas. La línea completa es un enunciado. Todo enunciado debe
terminar con un punto y coma (;) . Al ejecutarse el enunciado anterior, se exhibe el
mensaje Bienvenidos a la programación en JAVA en las coordenadas 25 y 25.
10
Las coordenadas se miden a partir de la esquina superior izquierda de la applet en

pixeles. Un píxel (o elemento de imagen) es la unidad de exhibición en la pantalla de
una computadora. En una pantalla a color un píxel aparece como un punto colorido.
Por ejemplo muchas computadoras personales tienen pantallas con una anchura de 640
pixeles y una altura de 480 pixeles, para un total de 640 x 480 = 307,200 elementos de
imagen exhibibles. Cuan mayor es la definición de la pantalla, mas pequeña se vera la
applet en la pantalla. La primera coordenada siempre es la coordenada x y la segunda
es la coordenada y.
Después de compilar el programa es necesario crear un archivo HTML (Hypertext

Markup Language, Lenguaje de marcado de hipertexto) para cargar la applet en un
navegador y ejecutarla. Los navegadores leen archivos de texto.
Archivo Welcome.html que carga la clase applet Welcome

1 <html>
2 <applet code = “Welcome.class” width=275 height=35>
3 </applet>
4 </html>
Las líneas 1 y 4 indican el principio y final de las condiciones HTML. Las líneas 2 y 3 son
etiquetas HTML especiales para las applets de Java; le indican al navegador que deben cargar
una applet especifica y definen el tamaño de la applet en el navegador. La primera parte (
code= Welcome.class) indica el archivo que contiene la clase de applet compilada que hemos
definido. Cuando compilamos un programa en Java, cada clase se compila en un archivo
individual que tiene el mismo nombre que la clase y termina con la e extensión .class. La
segunda y tercera parte indican la anchura (width) y la altura (height) de la applet en pixeles.
La esquina superior izquierda de la applet siempre esta en la coordenada x 0 y en la
coordenada y 0.
Para demostrar nuestra applet, usamos el comando appletviewer del Java Developer’s Kit
(JDK). Es un programa que prueba applets de Java; solo entiende la etiqueta HTML applet,
por lo que también se conoce como “el navegador mínimo”. Invocamos appletviewer para la
applet Welcome desde la línea de comando de nuestra computadora.
Appletviewer Welcome.html
El mensaje Bienvenidos a la programación en Java se puede imprimir de varias formas.

Dos enunciados drawString en el método paint pueden imprimir múltiples líneas:
1 //Un primer programa en Java

4
5 public class Welcome extends Applet {
6 public void paint(Graphics g)
7 {
11
8 g.drawString( "Bienvenidos a ", 25, 25 );

9 g.drawString(“la programación en JAVA”, 25, 40);
10 }
11 }
Otro programa en Java: Suma de enteros
Nuestro siguiente programa toma enteros que el usuario digita en el teclado, calcula la suma
de estos valores y exhibe el resultado. Cuando el usuario teclea un entero y presiona Enter, el
programa lee el entero y lo suma al total.
Este programa emplea algunos componentes de interfaz grafica con el usuario (GUI) de la
Java API. Los componentes de GUI son piezas que facilitan la introducción de datos por parte
del usuario del programa y la salida de datos por parte del programa.
1 // Programa de suma
2 import java.awt.*; //importar el paquete java.awt
3 import java.applet.Applet;
4
5 public class Addition extends Applet {
6 Label prompt; //solicitar entrada al usuario
7 TextField input; //introducir valores aquí
8 int number; //almacenar valor introducido
9 int sum; //almacenar suma de enteros
10
11 //preparar componentes de interfaz grafica de usuario
12 // e inicializar variables
13 public void init()
14 {
15 prompt = new Label ("Teclee un entero y pulse Enter:");
16 input = new Textfield(10);
17 add( prompt ); //poner prompt (solicitud) en la applet
18 add( input ); //poner input (entrada) en la applet
19 sum = 0; //hacer sum igual a cero
20 }
21
22 //procesar la acción del usuario en el campo de texto de entrada
23 public boolean action( Event e, Object o )
24 {
25 number = Integer.parseInt( o.toString() ); //obtener numero
26 input.setText( "" ); //despejar campo de entrada de datos
27 sum = sum + number; //suma number a sum
28 showStatus( Integer.toString( sum ) ); //mostrar resultado
29 return true; //indica que la acción del usuario se proceso
30 }
31 }
12
Import java.awt.*; Importa el paquete java.awt con todas las clases del paquete para la
compilación. Aquí se usaran las clases TextField y Label del paquete java.awt. Cuando
importamos un paquete completo, el compilador solo importa las clases que se usan en el
programa.
Label y TextField son objetos con información que el programa usa. Las variables y los
objetos son similares solo que un objeto se define mediante una definición de clase que puede
contener tanto información como métodos, una variable se define mediante un tipo de datos
primitivos (o integrado) . Cada elemento de datos en un programa Java es un objeto, con
excepción de las variables de tipo primitivo.
TextField (campo de texto) sirven para obtener información que el usuario introduce mediante
el teclado, o para exhibir información en la pantalla.
Label (rotulo) contiene una literal de cadena que se exhibe en la pantalla. Normalmente cada
rotulo esta asociado a otro elemento de la interfaz grafica en la pantalla ( como el campo de
texto en este programa).
Una variable debe de ser declarada antes de ser utilizada y termina con un punto y coma (;).
Un nombre de variable o de referencia es cualquier identificador valido . Un identificador es
una serie de caracteres que consiste en letras, dígitos, subrayados (_) y signos de dólar ($) que
no comienzan con un digito. Permite identificadores de cualquier longitud y es sensible a
mayúsculas y minúsculas. Es posible colocar declaraciones en una definición de método pero
debe aparecer antes que se use dicha variable.
Esta applet contiene dos métodos init y action. El método init se incluye en una applet para
inicializar las variables y referencias que se usan en la applet, se invoca automáticamente
cuando la applet comienza su ejecución, y se garantiza que será el primer método invocado.
De hecho las applets siempre comienzan con una serie de tres llamadas a métodos: init, start
y paint .
Si no definimos cualquiera de estos tres métodos, obtendremos de la clase Applet una versión
“gratuita” del método, el cual no hará nada. Esta es una de las razones por las que heredamos
todas las applets de la clase Applet.
El método action (acción) procesa interacciones entre el usuario y los componentes de interfaz
grafica con el usuario (GUI) de la applet. Una iteración entre un usuario y un componente
GUI genera un evento. Los eventos indican a la applet que el usuario esta interactuando con
uno de los componentes de GUI de la applet. Por ejemplo cuando introducimos un valor en el
campo de texto y pulsamos ENTER, se envía un evento ( que es un objeto de la clase Event
del paquete java.awt) a la applet, indicando que el usuario pulso la tecla enter en el campo de
texto. Esto hace que se ejecute de inmediato el método action. Este procesamiento de
interacciones del usuario con componentes GUI se conoce como programación controlada
por eventos.
13
La línea:
prompt = new Label ("Teclee un entero y pulse Enter:");
crea un objeto Label que se inicializa con la literal “Teclee un entero y pulse Enter:"
Usamos esta cadena para rotular el campo de texto input en la applet. El operador new crea un
objeto durante la ejecución del programa pidiéndole a la computadora suficiente memoria para
almacenar un objeto del tipo que se especifica a la derecha de new. El valor entre paréntesis se
usa para inicializar el objeto creado.
La línea input = new Textfield(10);
Crea un objeto TextField empleando el operador new y asigna el resultado a input. El numero
10 especifica el tamaño en caracteres del campo de texto en la pantalla.
Las líneas:
add( prompt );
add( input );
colocan los componentes label y TextField en la applet para que el usuario pueda interactuar
con ellos. El método add es uno de los muchos métodos de la clase Applet que heredamos
cuando definimos la clase Addition.
La línea: public boolean action( Event e, Object o )
Recibe dos argumentos: un Event (evento) y un Object (objeto). El argumento Event sirve
para determinar que evento ocurrió. Object contiene información especifica para el evento. En
el programa contiene el texto que estaba en el campo de texto. Object puede ser un objeto de
cualquier tipo (excepto variable); es el tipo mas genérico en el lenguaje de Java.
El método toString permite convertir cualquier objeto de cualquier tipo de clase en un String
(cadena).
La línea number = Integer.parseInt( o.toString() );
Asigna a number el resultado del método Integer.parseInt que convierte su argumento

String en un entero. La cadena que se convierte aquí es el resultado del método o.toString()
que convierte el Object llamado o en un String. Cualquier referencia a number en el
programa utilizara este mismo valor entero.
La línea input.setText( "" );
Utiliza el método SetText de la clase TextField para asignar la cadena vacía al campo de texto
input, borrando el texto que el usuario haya dejado en el campo de texto.
14
Después de realizar el calculo, exhibimos el resultado en la barra de estado que esta en la parte
inferior de la ventana de appletviewer ( o del navegador).
La línea showStatus( Integer.toString( sum ) );
Utiliza el método showStatus de la clase Applet para colocar un String en la barra de estado.
El String que se exhibe es el resultado del método Integer.toString(sum) que toma el entero
sum y lo convierte en un String.
La línea return true;
Le indica a action que devuelva el valor true a la applet cuando haya terminado su tarea. Esto
le dice a la applet que ya se proceso la acción del usuario que causo el evento.
Unidad II: Operadores y Tipos de datos
2.1 Operadores Aritméticos
Operación de Java Operador aritmético Expresión algebraica Expresión en Java

Suma + f+7 f+7
Resta - p-c p-c
Multiplicación * bm b*m
División / x/y x/y
Residuo % r mod s r%s
2.2 Operadores de igualdad y relacionales
Operadores algebraicos Operadores en Java Ejemplo en Java

Operadores de igualdad
= == x==y
≠ != x != y
Operadores relacionales
> > x>y
< < x<y
≥ >= x >= y
≤ <= x <= y
2.3 Operadores de incremento y decremento
Operador Llamado Expresión de muestra Explicación

Preincremento ++a Incrementa a en 1 y luego usa el nuevo valor de a en
la expresión en la que a reside
Posincremento a++ Usar el valor actual de a en la expresión en la que
reside y luego incrementar a en 1
15
Predecremento --b Decrementar b en 1 y luego usar el nuevo valor de b

en la expresión en la que b reside
posdecremento b-- Usar el valor de b en la expresión en la que reside y
luego decrementar b en 1
2.4 Operadores de Asignación
Operador de Asignación Expresión de muestra Explicación

+= c += 7 c=c+7
-= d -= 4 d=d–4
*= e *= 5 e=e*5
/= f /= 3 f=f/3
%= g %= 9 g=g%9
2.5 Operador condicional (?:).
Es el único operador ternario de Java: requiere tres operándoos. El primer operando es una
expresión bolean, el segundo la expresión si la condición es verdadera y el tercero la expresión
si la condición es falsa.
condición ? expresión V: expresión F
System.out.println( calif >= 60 ? “Aprobado” : “Reprobado”);
Precedencia de los operadores
Operadores
()
++ -- + - (unario)
* / %
+ - (aditivo)
< <= > >=
== !=
? : condicional
= += -= *= /= %=
2.6 Tipos de datos primitivos
Tipo Tamaño en bits Valores

bolean 1 True o false
char 16 ‘\u0000’ a ‘\uFFFF’
byte 8 -128 a +127
short 16 -32,768 a 32,767
16
int 32 -2,147,483,648 a +2,147,483,647

long 64 -9,223,372,036,854,775,808 a
+9,223,372,036,854,775,807
float 32 -3.40292347E+38 a +3.40292347E+38
double 64 -1.79769313486231570E+308 a
+1.79769313486231570E+308
2.7 Secuencias comunes de escape
Secuencia Descripción
\n Nueva línea. Coloca el cursor al principio de la siguiente línea
\t Tabulación horizontal
\r Retorno de carro. Coloca el cursor al principio de la línea actual; no avanza
a la siguiente línea
\\ Imprime el carácter de diagonal invertida
\’ Imprime un carácter de apostrofo
\” Imprime un carácter de comillas
17
Unidad III: Estructuras de Control
3.1 Estructura if
if (condición)
enunciado;
Ejm:
if (calif >= 60)

System.out.println( “Aprobado”);
3.2 Estructura if / else
if (condición)
enunciado V;
else
enunciado F;
Ejm:
if (calif >= 60)

System.out.println( “Aprobado”);
else
System.out.println( “Reprobado”);
3.3 Estructura if / else anidadas
if (condición 1)
enunciado 1;
else if (condición 2)
enunciado 2;
else if (concisión 3)
enunciado 3;
else
enunciado;
18
Ejm:
if (calif >= 90)

System.out.println( “A” );
else if (calif >= 80)
System.out.println( “B” );
System.out.println( “C” );
System.out.println( “D” );
else System.out.println( “F” );
Hay que tener cuidado con la interpretación del compilador, por ejemplo: la siguiente
estructura:
if ( x > 5 )
if ( y > 5 )
System.out.println( “x y y son > 5” );
else System.out.println( “x es <= 5” );
pareciera que si x es menor o igual a 5 se imprimiría el mensaje “x es >= 5”, pero el

compilador la interpreta de la siguiente manera:
if ( x > 5 )
if ( y > 5 )
Es decir que si x es mayor que 5 entra a la segunda condición y el mensaje x es <=5 se

imprimirá si la segunda condición es falsa. Para imprimir correctamente se deberá añadir
llaves. Ejm:
if ( x > 5 ) {
if ( y > 5 )
}
Si se desean incluir varios enunciados en el cuerpo de un if, debemos encerrarlos entre llaves .
Un grupo de enunciados contenidos dentro de un par de llaves es un enunciado compuesto.
19
Ejm:
if ( calif >= 60 )
System.out.println( “Aprobado” );
Else {
System.out.println( “Reprobado” );
System.out.println( “Debe cursar otra vez la materia” );
}
3.4 Estructura de repetición while
while (condición)
sentencia;
while (condición) {
sentencia 1;
sentencia 2;
sentencia N;
}
3.5 Estructura de repetición for
for ( inicialización de la variable contadora; condición; incremento de la variable contadora)

enunciado;
for( int j=2; j <= 8; j++) {

g.drawString( integer.toString( j ), 25, yPos);
yPos += 15;
}
for( int i = 7, i>= 2; i--)
3.6 Estructura de repetición do / while
do{
enunciado
}
while (condición);
20
3.7 estructura de selección múltiple switch
switch (expresión) {
case valor1:
sentencia;
break;
case valor2: case valor3:

sentencia;
break;
default:
sentencia;
break;
}
3.8 Enunciados break y continue rotulados
break solo puede causar la salida de la estructura while, for, do/while o switch que lo
encierra directamente. Si queremos salir de una serie de estructuras anidadas o cíclicas,
podemos usar break rotulado, utilizando
break stop;
continue continua con la siguiente iteración de la estructura while, for o do/while
Ejemplos:
// Promedio1.java
// programa del promedio de una clase mediante la repetición controlada por contador while
import javax.swing.JOptionPane;
public class Promedio1 {

{
int total;
int cont;
int calificacion;
int promedio;
String calif; // calificación introducida por el usuario
total = 0;
cont = 1;
21
while ( cont <= 10 ) {
// pedir la entrada y leer la calificación del usuario

calif = JOptionPane.showInputDialog( "Escriba la calificación como un entero: " );
calificacion = Integer.parseInt( calif );
total = total + calificacion;

cont = cont + 1;
} // end while
// fase de terminacion
promedio = total / 10;
// mostrar el promedio de las calificaciones del usuario

JOptionPane.showMessageDialog( null, "Promedio de la clase " + promedio,
"Promedio de la clase", JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 ); // terminate the program
} // end main
} // end class Promedio1
// Promedio2.java
// Promedio de una clase controlado por centinela while
import java.text.DecimalFormat; // clase para dar formato a los números
public class Promedio2 {

{
int total;
int cont;
int calificacion;
double promedio; // numero con punto decimal para el promedio
String calif;
total = 0;
cont = 0;
22
// obtener la primera calificación del usuario

calif = JOptionPane.showInputDialog("Escriba calificación como entero o -1 para salir:" );
// iterar hasta que el usuario introduzca el valor centinela

while ( calificacion != -1 ) {
total = total + calificacion;
cont = cont + 1;
// obtener siguiente calificación del usuario

calif = JOptionPane.showInputDialog("Escriba calificación como entero o -1 para
salir:");
} // end while
/* declara dos digitos como una referencia a un objeto de la clase DecimalFormat

dando
formato a los números */
DecimalFormat dosDigitos = new DecimalFormat( "0.00" );
// si el usuario introdujo al menos una calificacion

if ( cont != 0 ) {
// calcular el promedio
promedio = (double) total / cont;
// mostrar el promedio con dos digitos de precision

JOptionPane.showMessageDialog( null,"Promedio de la clase es: " + twoDigits.format(
promedio ), "Promedio de la clase", JOptionPane.INFORMATION_MESSAGE );
} // fin del if
else // si no se introdujo calificacion
JOptionPane.showMessageDialog( null, "No se introdujeron calificaciones",
"Promedio de la clase", JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
23
// ContadorWhile.java
// Applet
import java.awt.Graphics;
import javax.swing.JApplet;
public class ContadorWhile extends JApplet {
// dibujar lineas en el fondo del applet

public void paint( Graphics g )
{
super.paint( g ); // llama al metodo Saint heredado de JApplet
int cont = 1;
while ( cont <= 10 ) {

g.drawLine( 10, 10, 250, cont * 10 );
++cont; // incremento
} // fin while
} // fin del metodo paint
} // fin de la clase
// ContadorFor.java
// dibuja lineas en el fondo del applet
public class ContadorFor extends JApplet {

{
super.paint( g );
for ( int cont = 1; cont <= 10; cont++ )

g.drawLine( 10, 10, 250, cont * 10 );
24
/* Una persona invierte $1000.00 en una cuenta de ahorro que produce el 5% de interés.
Suponiendo que todo el interés se deposita en la cuenta, calcule e imprima el monto de dinero
en la cuenta al final de cada año, durante 10 años. Use la siguiente formula para determinar el
monto: c = p(1+t)n : donde p es el monto que se invirtió originalmente; t es la tasa de interés
anual; n es el numero de años; c es la cantidad depositada al final del n-esimo año */
// Interes.java
// Calculo del interes compuesto
import java.text.NumberFormat; // clase para el formato numerico
import java.util.Locale; // clase para información especifica de cada pais
import javax.swing.JTextArea;
public class Interes {

{
double cantidad; // cantidad depositada al final de cada año
double principal = 1000.0; // cantidad inicial sin intereses
double tasa = 0.05; // tasa de interes
// crear NumberFormat para la moneda en dolares

NumberFormat formatoMoneda = NumberFormat.getCurrencyInstance( Locale.US );
// crear JTextArea para mostrar la salida

JTextArea areaTextoSalida = new JTextArea();
// establecer la primera linea de textoen areaTextoSalida

areaTextoSalida.setText( "Año\tCantidad en deposito\n" );
// calcular la cantidad en deposito para cada uno de los diez años

for ( int year = 1; year <= 10; year++ ) {
// calcular la nueva cantidad para el año especifico

cantidad = principal * Math.pow( 1.0 + tasa, year );
// anexar una linea de texto a areaTextoSalida

areaTextoSalida.append( year + "\t" + formatoMoneda.format( cantidad ) + "\n" );
} // fin for
// mostrar resultados
JOptionPane.showMessageDialog( null, areaTextoSalida,”Interes Compuesto",
JOptionPane.INFORMATION_MESSAGE );
25
System.exit( 0 );
} // fin main
} // fin de la clase Interes
Ciclo do while
// PruebaDoWhile.java
public class PruebaDoWhile extends JApplet {
// dibuja circulos en la applet

{
super.paint( g );
int cont = 1;
do {
g.drawOval( 110 - cont * 10, 110 - cont * 10,
cont * 20, cont* 20 );
++cont;
} while (cont <= 10 );
} // fin Saint
} // fin clase
// PruebaSwitch.java
// Dibuja lineas, rectangulos u ovalos con base en la entrada del usuario
import javax.swing.*;
public class PruebaSwitch extends JApplet {

int opcion; // la opcion del usuario en cuanto a cual figura dibujar
// inicializar el applet, obteniendo la opcion del usuario

public void init()
{
String entrada; // entrada del usuario
// obtener la opcion del usuario

entrada = JOptionPane.showInputDialog(
"Escriba 1 para dibujar lineas\n" +
" Escriba 2 para dibujar rectangulos \n" +
" Escriba 3 para dibujar ovalos\n" );
26
opcion = Integer.parseInt(entrada );
} // fin del init
// dibujar figuras en el fondo del applet

{
super.paint( g );
for ( int i = 0; i < 10; i++ ) {
switch ( opcion ) { // determina la figura a dibujar
case 1: // dibuja linea

g.drawLine( 10, 10, 250, 10 + i * 10 );
break; // fin del procesamiento del case
case 2: // dibuja rectangulo

g.drawRect( 10 + i * 10, 10 + i * 10, 50 + i * 10, 50 + i * 10 );
case 3: // dibuja ovalo

g.drawOval( 10 + i * 10, 10 + i * 10, 50 + i * 10, 50 + i * 10 );
default: // dibujar cadena indicando que se escribió un valor incorrecto

g.drawString( "Se escribio un valor incorrecto", 10, 20 + i * 15 );
} // fin switch
} // fin for
} // fin paint
27
Unidad IV: Métodos
Módulos de programas en Java
Hay dos tipos de módulos en Java: métodos y clases. La API de java proporciona una vasta
colección de clases que contienen métodos para realizar cálculos matemáticos, manipulaciones
de cadenas, manipulaciones de caracteres, operaciones de entrada / salida, comprobación de
errores y muchas otras operaciones útiles. Las clases de la API de Java forman parte del Kit de
desarrollo de software para Java 2 (J2SDK), el cual contiene miles de clases preempacadas.
Los métodos también conocidos como funciones o procedimientos permiten al programador

dividir un programa en módulos, por medio de la separación de sus tareas en unidades
autónomas, también conocidas como métodos declarados por el programador. Las
instrucciones que implementan los métodos se escriben solo una vez y están ocultas de otros
métodos.
Entre las razones para crear un programa en módulos por medio de los métodos es la
metodología divide y vencerás hace que el desarrollo de programas sea mas fácil de
administrar. Otra razón es la reutilización de software (usar los métodos existentes como
bloques de construcción para crear nuevos programas).
Un método se invoca o se llama mediante la llamada a un método, especificando el nombre

del método y proporcionando información (argumentos) que el método llamado requiere para
realizar su tarea. Una vez que se ha completado la llamada, el método devuelve el resultado al
solicitante ( o método que hizo la llamada) o simplemente le devuelve el control.
Métodos de la clase Math
Permite realizar cálculos comunes. Para llamar a un método se escribe su nombre seguido de
un paréntesis de apertura, después su argumento ( o una lista de argumentos separados por
comas) y al final un paréntesis de cierre.
Ejm:
1. Math.sqrt (900.00 ) Raíz cuadrada de 900.00
2. System.out.println( Math.sqrt( 900.00);
No es necesario importar la clase Math para utilizar sus métodos. Math es parte del paquete
java.lang, el cual se importa automáticamente por el compilador. Los argumentos pueden ser
constantes, variables o expresiones. Ejm:
3. System.out.println( Math.sqrt( c + d * f );
28
método Descripción Ejemplo

abs( x ) Valor absoluto de x (float, int, long) abs( 23.7 ) es 23.7
abs( -23.7 ) es 23.7
ceil( x ) Redondear x al entero mas pequeño que no sea ceil( 9.2 ) es 10.0
menor de x ceil( -9.8) es -9.0
cos( x ) Coseno trigonométrico de x (x esta en radianes) cos( 0.0 ) es 1.0
exp( x ) método exponencial ex exp( 1.0 ) es 2.71828
exp(2.0 ) es 7.38906
floor( x ) Redondea x al entero mas grande que no sea floor( 9.2 ) es 9.0
mayor de x floor( -9.8 ) es -10.0
log( x ) Logaritmo natural de x (base e) log( Math.E) es 1.0
log(Math.E * Math.E ) es -
2.3
max( x, y ) El valor mas grande de x y y (float, int, long) max( 2.3, 12.7 ) es 12.7
max(-2.3, -12.7) es -2.3
min( x, y ) El valor mas pequeño de x y y (float, int, long) min( 2.3, 12.7 ) es 2.3
min(-2.3, -12.7) es -12.7
pow( x, y ) X elevado a la potencia de y (xy) pow( 2.0, 7.0 ) es 128.0
pow( 9.0, 0.0 ) es 3.0
sin( x ) Seno trigonométrico de x ( x esta en radianes) sin( 0.0 ) es 0.0
sqrt( x ) Raíz cuadrada de x sqrt( 900.00 ) es 30.0
sqrt( 9.0 ) es 3.0
tan( x ) Tangente trigonometrica de x ( x esta en tan( 0.0) es 0.0
radianes)
Math.PI Constante (3.14159265358979323846)
Math.E Constante (2.7182818284590452354)
29
4.3 Formato general de la declaración de un método definido por el usuario
Tipo-de-valor-de-retorno nombre-del-método (parametro1,parametro2, …, parametroN)

{
Declaraciones e instrucciones;
[ return expresión;]
}
Los métodos pueden devolver como máximo un valor. Los parámetros se declaran en una lista
separada por comas, encerrada entre paréntesis, que declara el tipo y nombre de cada uno de
los parámetros. Debe haber un argumento en la llamada al método para cada parámetro en la
declaración del método, cada argumento debe ser compatible con el tipo del parámetro
correspondiente.
Se han visto tres maneras de llamar a un método:
1. El nombre del método por si solo cuadrado (contador)

2. la referencia a un objeto seguido de un punto y el nombre del objeto
g.drawLine(15,10,20,10)
3. El nombre de la clase calificando al nombre de un método
Integer.parseInt(pnumero)
4.4 Promoción de argumentos
La promoción o coerción de argumentos es forzar a que se pasen argumentos del tipo

apropiado a un método. Las reglas de promoción se aplican a las expresiones que contienen
valores de dos o mas tipos primitivos y a los valores de tipos primitivos que se pasan como
argumentos a los métodos. El tipo de cada valor en una expresión se promueve al tipo “mas
alto” en la expresión.
Promociones permitidas para los tipos primitivos
Tipo promoción valida

double Ninguna
float double
long Flota o double
int long, float, o double
char int, long, flota o double
short int, long, float o double
byte short, int, long, float o double
boolean Ninguno
30
// CuadradosEnteros.java
// Crear y utilizar un metodo definido por el programador
import java.awt.Container;
public class CuadradosEnteros extends JApplet {
// configurar GUI y calcular los cuadrados de los enteros del 1 al 10
public void init()

{
// objeto JTextArea para mostrar resultados
JTextArea areaSalida = new JTextArea();
/* obtener panel de contenido del applets (area visible del

componente de la GUI)*/
Container contenedor = getContentPane();
/* metodo heredado de JApplet.Devuelve una referencia al objeto del panel

de contenido del applet. El programa usa esta referencia para adjuntar
componentes de la GUI (JTextArea) */
// adjuntar areaSalida al contenedor

contenedor.add( areaSalida ); // add es un metodo
int resultado; // guardar el resultado de la llamada al método cuadrado
String salida = "";
for ( int cont = 1; cont <= 10; cont++ ) {

resultado = cuadrado( cont ); // llamada al metodo
// anexar resultado al objeto String salida
salida += "El cuadrado de " + cont + " es " + resultado + "\n";
} // end for
areaSalida.setText( salida ); // colocar resultado en el objeto

JTextArea
} // fin del metodo init
// declaracion del metodo cuadrado
public int cuadrado( int y )

{
return y * y; // devolver cuadrado de y
} // fin metodo cuadrado

31
// PruebaMaximo.java
// Encontrar el valor maximo de tres numeros de punto flotante
public class PruebaMaximo extends JApplet {
// inicializar el applet, obtener la entrada del usuario y crear GUI

public void init()
{
// obtaiobtener entrada del usuario
String s1 = JOptionPane.showInputDialog(
"Escriba el primer valor de punto flotante" );
"Escriba el segundo valor de punto flotante" );
" Escriba el tercer valor de punto flotante " );
// convertir a valores double la entrada del usuario

double numero1 = Double.parseDouble( s1 );
double max = maximo( numero1, numero2, numero3 ); // llamada al

metodo
// mostrar los numeros y el valor maximo

areaSalida.setText( "numero1: " + numero1 + "\nnumero2: " +
numero2 + "\nnumero3: " + numero3 + "\nmaximo es: " + max );
// obtener el area visible del applet para componentes GUI

// adjuntar areaSalida al contenedor

container.add( areaSalida );
} // fin del metodo init
// el metodo maximo utiliza el metodo max de la clase Math para

// determinar el valor máximo
public double maximo( double x, double y, double z )

{
return Math.max( x, Math.max( y, z ) );
} // fin de maximo
32
//Asterisco.java
// Imprime un triangulo de asteriscos
public class Asterisco extends JApplet {

int na;
public void init()
{
String nasterisco;
nasterisco = JOptionPane.showInputDialog( "De el numero de asteriscos");
na=Integer.parseInt(nasterisco);
}
public void paint( Graphics g)
{
int a;
super.paint(g);
int ypos= 25;
for(a=1; a <= na; a++ )
{
g.drawString(imprime(a),25, ypos);
ypos += 15;
}
public String imprime( int ast)

{
String resultado="";
for(int i=1; i<= ast; i++)
resultado += "*";
return resultado;
}
}
33
Unidad V: Arreglos
Introducción
Los arreglos son estructuras de datos que consisten de elementos de datos relacionados, del
mismo tipo. Son entidades de longitud fija, conservan siempre la misma longitud una vez
creados.
En Java los tipos de datos se dividen en dos categorías tipos primitivos y tipos de referencia.
Los arreglos en Java son objetos, por lo que se consideran como tipos de referencia. Para hacer
referencia a un elemento especifico en un arreglo, debemos especificar el nombre de la
referencia al arreglo y el numero de la posición del elemento especifico en el arreglo. El
numero de la posición del elemento se conoce formalmente como el índice o subíndice del
elemento. El primer elemento en cualquier arreglo tiene el índice cero. Un índice debe ser un
entero positivo o una expresión entera que pueda promoverse a un int. Ejm:
c[ 5 ] = 3; c[ a + b ] += 2;
Declaración y creación de arreglos
Los objetos arreglo ocupan espacio en memoria. Todos los objetos en Java deben crearse con
la palabra clave new. El programador especifica el tipo de cada elemento y el numero de
elementos que se requieren para el arreglo, como parte de una expresión para crear un arreglo
que utiliza la palabra clave new. Ejm:
int c[] = new int [ 12 ]; o
int c[];
c = new int [ 12 ];
Un programa puede crear varios arreglos en una sola declaración:
String b [] = new String[ 100 ], x [] = new String [ 27 ];
Al declarar un arreglo, su tipo y los corchetes pueden combinarse al principio de la

declaración para indicar que todos los identificadores en la declaración son referencias a
arreglos.
double[] arrego1, arreglo2;
Al crear un arreglo cada uno de sus elementos recibe un valor predeterminado: cero para los
elementos numéricos de tipos primitivos. false para los elementos bolean y null para las
referencias (cualquier tipo de primitivo).
34
Como pasar arreglos a los métodos
Para pasar un arreglo como argumento a un método, se especifica el nombre del arreglo sin
corchetes. Ejemplo:
int temperatura[] = new int[ 24 ];
llamada al método
modificarArreglo(temperatura);
aunque los arreglos completos se pasan por referencia, los elementos individuales de los
arreglos de tipos primitivos se pasan por valor, de la misma forma que se pasan las variables
simples. Para que un método reciba un arreglo mediante una llamada:
void modificarArreglo( int b[] )
Ejemplos:
En el ciclo for se utiliza la expresión array.length para determinar la longitud del arreglo . en
este ejemplo la longitud del arreglo es 10, por lo que el ciclo continua ejecutandose siempre y
cuando el valor de la variable de control cont sea menor que 10.
// InicArreglo.java
// Creación de un arreglo
public class InicArreglo {

{
int array[]; // declarar la referencia a un arreglo
array = new int[ 10 ]; // crear el arreglo
String salida = "Indice\tValor\n";
// anexar el valor de cada elemento del arreglo al String salida
for ( int cont = 0; cont < array.length; cont++ )

salida += cont + "\t" + array[ cont ] + "\n";

areaSalida.setText( salida );
JOptionPane.showMessageDialog( null, areaSalida,

"Inicializacion de un arreglo de valores int",
System.exit( 0 );
} // end main
} // end class InicArreglo
35
// Arreglo2.java
// Inicializacion de un arreglo con una declaracion
public class Arreglo2 {

{
// la lista inicialaizadora especifica el numero de elementos y
// el valor de cada elemento
int array[] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
String salida = "Indice\tValor\n";

salida += cont + "\t" + array[ cont ] + "\n";


"Inicializacion de un arreglo con una declaracion",
System.exit( 0 );
} // end main
} // end class Arreglo2
// Histograma.java
public class Histograma {

{
int array[] = { 3, 1, 2, 7, 11, 9, 13, 5, 17, 1 };
String salida = "Elemento\tValor\tHistograma";
// para cada elemento del arreglo, mostrar una barra en el histograma

{
salida += "\n" + cont + "\t" + array[ cont ] + "\t";
// imprimir barra de asteriscos

for ( int ast = 0; ast < array[ cont ]; ast++ )
salida += "*";

36

"Programa para imprimir histograma", JOptionPane.INFORMATION_MESSAGE
);
System.exit( 0 );
} // end main
} // end class Histograma
37
Arreglos Multidimensionales
Constan de información ordenada en filas y columnas. Para identificar un elemento especifico

de una tabla, se deben identificar dos índices [fila, columna].
Creación de un array bidimensional
int b[];
b = new int [3][4];
al igual que los array unidimensionales , los bididimensionales pueden también ser
inicializados en la declaración:
int b[]= { { 1, 2 }, { 3, 4 } };
b[0][0]=1
b[0]1 ]=2
b[1][0]=3
b[1][1]=4
En Java, los arrays multidimensionales se mantienen como arrays de arrays unidimensionales.

Por lo tanto el array b en la declaración anterior en realidad esta compuesto de 3 arrays
unidimensionales separados. El array b en si es un array unidimensional que contiene dos
elementos. Cada elemento es una referencia a un array unidimensional de variables int.
Arrays bidimensionales con filas de distintas longitudes
Las longitudes de las filas en un array no tienen que ser iguales. Ejm:
int b[]= { { 1, 2 }, { 3, 4, 5 } };
crea el array entero b con 2 elementos (los cuales se determinan según el numero de
inicializadotes de arrays anidados) que representan las filas del array bidimensional. Cada
elemento de b es una referencia a un array unidimensional de variables int. El array int de la
fila 0 es un array unidimensional de 2 elementos (1 y 2), y el array int de la fila 1 es un array
unidimensional con 3 elementos (3, 4 y 5).
Un array bidimensional en que cada fila tiene un numero distinto de columnas, puede crearse
de la siguiente manera:
int b[];
b = new int [2][ ]; // crea dos filas
b[0] = new int[ 5 ]; //crea 5 columnas para la fila 0
b[1] = new int[ 33]; //crea 5 columnas para la fila 1
38
Ejercicios:
// ArrayBidi.java
// Inicializacion de arrays bidimensionales.
public class ArrayBidi extends JApplet {

JTextArea areaSalida;
public void init()

{
areaSalida = new JTextArea();
contenedor.add( areaSalida );
int array1[][] = { { 1, 2, 3 }, { 4, 5, 6 } };
int array2[][] = { { 1, 2 }, { 3 }, { 4, 5, 6 } };
areaSalida.setText( "Los valores en array1 por fila son\n" );

crearSalida( array1 ); // llamada a metodo
outputArea.append( "\nLos valores en array2 por fila son\n" );

crearSalida( array2 );
} // end method init
// anexar filas y columnsa de un array a areaSalida

public void crearSalida( int array[][] )
{
// iterar a traves de las filas del array
for ( int fila = 0; fila < array.length; fila++ ) {
// iterar a traves de las columnas del array

for ( int column = 0; column < array[ row ].length; column++ )
areaSalida.append( array[ fila ][ column ] + " " );
areaSalida.append( "\n" );
}
} // end method crearSalida
} // end class ArrayBidi
39
Leer un arreglo bidimensional de m filas y n columnas, imprimir el arreglo

y clacular la suma de las filas y la suma de las columnas.
// ArrayBidi
// Procesamiento en arreglos bidimensionales
public class ArrayBidi{

public static void main(String args[])
{
int nf,nc,f,c;
String nfil,ncol,elem,salida="";
do
{
nfil=JOptionPane.showInputDialog("De el numero de filas no mas de 5");
nf=Integer.parseInt(nfil);
}while(nf > 5);
do
{
ncol=JOptionPane.showInputDialog("De el numero de columnas no mas de
5");
nc=Integer.parseInt(ncol);
} while(nc > 5);
int x[][]= new int[nf][nc];
int sf[]=new int[nf];
int sc[]= new int[nc];
for(f=0;f<nf;f++)
for(c=0;c<nc;c++)
{
elem=JOptionPane.showInputDialog("Int. elemento");
x[f][c]= Integer.parseInt(elem);
sf[f] += x[f][c];
}
for(c=0;c<nc;c++)
for(f=0;f<nf;f++)
sc[c] += x[f][c];
salida += "Matriz X\n";

for(f=0;f<nf;f++)
{
for(c=0;c<nc;c++)
salida += x[f][c] + "\t";
salida += "\n";
}
salida += "\n\n Suma de elementos por fila \n";

for(f=0;f<nf;f++)
salida += sf[f] + "\t";
salida += "\n\n Suma de elementos por columna \n";

for(c=0;c<nc;c++)
salida += sc[c] + "\t";

areaSalida.setText(salida);
JOptionPane.showMessageDialog(null,areaSalida);
40
System.exit(0);
}
}
Escribir una aplicación que lea el nombre y 4 notas de N estudiantes. Dentro de un metodo calcular el
promedio, el cual deberá ser de las 3 notas más altas y deberá de calcular el promedio general. En
otro metodo deberá de solicitarle al usuario cual de las 4 notas desea saber su nota mas baja y el
nombre del estudiante que la obtuvo. Imprimir en una tabla la información Ejemplo:
NOMBRE NOTAS N.BAJA PROMEDIO

Juan Solis 78 65 98 32 32 80
Martha Bermudez 46 82 72 71 46 75
Promedio General: 78
La nota mas minima de la nota 2 la obtuvo Juan Solis, la cual fue de 65
//Notas.java
// Arreglo bidimensional de notas
public class Notas {

public static void main(String args[])
{
int n,f,c,ind,prog,not,col;
String na,nota,salida="";
na=JOptionPane.showInputDialog("De el numero de alumnos");
n=Integer.parseInt(na);
String nomb[]=new String[n];
int notas[][]= new int[n][4];
int baja[]=new int[n];
int prom[]= new int[n];
for(f=0;f<n;f++)
{
nomb[f]=JOptionPane.showInputDialog("De el nombre del alumnos");
not=0;
for(c=0;c<4;c++)
{
not= c+1;
nota= JOptionPane.showInputDialog("De la nota:" + not);
notas[f][c]= Integer.parseInt(nota);
}
}
prog = Calculo(notas,baja,prom,n);
salida += "NOMBRE\t\t\tNOTAS\t\tBAJA\tPROMEDIO";
for(f=0;f<n;f++)
{
salida += "\n" + nomb[f] + "\t";
for(c=0;c<4;c++)
salida += notas[f][c] + "\t";
salida += baja[f] + "\t" + prom[f];
}
41
// encontrar el estudiante con la nota minima de una nota determinada

nota = JOptionPane.showInputDialog("De cual de las 4 notas quiere saber que
estudiante tiene el minimo:");
c = Integer.parseInt(nota);
ind= Minimo(notas,n,c);
col=c-1;
salida += "\n\n La nota minima de la nota " + c + " la obtuvo: " + nomb[ind] + " la cual
fue de: " + notas[ind][col];
areaSalida.setText(salida);
JOptionPane.showMessageDialog( null,areaSalida);
System.exit(0);
}
public static int Calculo(int notas[][],int baja[],int prom[], int n)

{
int p,suma,sp=0;
for(int f=0;f<n;f++)
{
suma=0;
baja[f]=notas[f][0];
for(int c=0;c<4;c++)
{ suma += notas[f][c];
if(notas[f][c] < baja[f])
baja[f] = notas[f][c];
}
prom[f]= (suma - baja[f])/3;
sp += prom[f];
}
p = sp/n;
return p;
}
public static int Minimo(int notas[][], int n,int c)
{
int i=-1,min=100,col;
col=c-1;
for(int f=0; f<n; f++)
if(notas[f][col] < min )
{
min =notas[f][col];
i = f;
}
return i;
}
42

COMO PROGRAMAR EN JAVA para Estudiantes PDF

Caricato da

Informazioni sul documento

Descrizione originale:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

COMO PROGRAMAR EN JAVA para Estudiantes PDF

Caricato da

Copyright:

Formati disponibili

Folleto elaborado por: MSc.

Janine Mairena Solorzano

COMO PROGRAMAR EN JAVA

1.1 Historia de Java

Sun Microsystems reconociendo que los microprocesadores tendrán un impacto profundo en

No obstante el proyecto Green se vio en problemas. El mercado para dispositivos electrónicos

Sun anuncio formalmente Java en una conferencia importante en mayo de 1995.

1.2 Biblioteca de clases de Java

El empleo de clases y métodos de biblioteca en lugar de versiones propias puede mejora el

1.3 Fundamentos de un entorno Java típico

Los sistemas Java generalmente constan de varias partes:

En la fase 2, el programador emite el comando javac para compilar el programa. El

Si el programa se compila correctamente, se producirá un archivo llamado Welcome.class

Al igual que Nestcape Navegator y HotJava, appletviewer requiere de un documento HTML

En la fase 5 la computadora controlada por el CPU, interpreta el programa un código de byte

Fig 1.1 Un entorno de Java típico

Editor Disco El programa se crea en el editor y se

El compilador crea códigos de bytes y los

Unidad II: Introducción a las aplicaciones en Java

public class Bienvenido {

// el método main empieza la ejecución de la aplicación en Java

public class Bienvenido1 {

public class Bienvenido2 {

public static void main( String args[] )

Como mostrar texto en un cuadro de dialogo.

La clase JOptionPane de Java proporciona cuadros de diálogos previamente empaquetados,

// Imprimir varias líneas de texto en un cuadro de dialogo

public class Bienvenido3 {

public static void main ( String args[] )

System.exit( 0 ); //terminar la aplicación con la ventana

El método showMessageDialog de la clase JOptionPane muestra un cuadro de dialogo para

Ejm 2: Suma de enteros

// Programa que muestra la suma de dos números

public class Suma{

// el método empieza la ejecución de la aplicación en Java

int n1; // primer numero a sumar

// leer el primer numero como una cadena

// leer el segundo numero

// Convertir los números de tipo String a tipo int

// Sumar los números

} // Fin del método main

El tercer argumento de JOptionPane.showMessageDialog “Resultados” se coloca en la

Tipo de cuadro de dialogo de mensaje Icono Descripción

1.5 Introducción a la programación en Java

1 //Un primer programa en Java

1 // indica que el resto de la línea es un comentario.

2 Java contiene muchos componente predefinidos llamados clases que se agrupan

2 import java.applet.Applet; //importar la clase Applet

public class Welcome extends Applet {

public void paint(Graphics g)

Introduce un bloque de construcción de programa llamado método. Los programas java

La llave { inicia el cuerpo de la definición del método. La llave } debe terminar el

g.drawString( "Bienvenidos a la programación en JAVA", 25, 25 );

Ordena a la computadora realizar una acción, a saber, usar el método drawString

Las coordenadas se miden a partir de la esquina superior izquierda de la applet en

Después de compilar el programa es necesario crear un archivo HTML (Hypertext

Archivo Welcome.html que carga la clase applet Welcome

El mensaje Bienvenidos a la programación en Java se puede imprimir de varias formas.

1 //Un primer programa en Java

8 g.drawString( "Bienvenidos a ", 25, 25 );

Otro programa en Java: Suma de enteros

prompt = new Label ("Teclee un entero y pulse Enter:");