INSTITUTO_TECNOLOGICO_DE_MORELIA_PROGRAM.pdf

MORELIA, MICHOACÁN 20/06/09
INSTITUTO TECNOLÓGICO DE MORELIA
DIVISIÓN DE ESTUDIOS PROFESIONALES
DEPARTAMENTO DE SISTEMAS
COMPUTACIONALES
PROGRAMACIÓN II
QUE PARA OBTENER EL TÍTULO DE:
INGENIERO EN SISTEMAS COMPUTACIONALES
PRESENTA:
SAÚL CHÁVEZ VELÁZQUEZ
ASESOR:
RAYMUNDO GUZMÁN MARINES
SUBSECRETARÍA DE EDUCACIÓN SUPERIOR
DIRECCIÓN GENERAL DE EDUCACIÓN SUPERIOR
TECNOLÓGICA
INSTITUTO TECNOLÓGICO
DE MORELIA

Agradecimientos
Agradezco todo el apoyo de mi Asesor Raymundo Guzmán Marines sin el cual
no habría sido posible la culminación de este trabajo. Gracias por todo su
tiempo, su comprensión, sus consejos y su trabajo…
A mis padres, por todo su apoyo, sin él no podría haber llegado a este punto…
Y a quienes debo lo bueno que haya en mi.
A Verónica, por su ayuda, por el soporte que siempre me ha brindado, siempre
puedo contar con ella. ¡Gracias por todo!
A mi abuelita Angelina, quien siempre me ha servido como ejemplo de trabajo y
esfuerzo. Una persona admirable, si todos tuviéramos la mitad de su energía,
entusiasmo y amor por hacer las cosas bien seguramente el mundo estaría
lleno de gente exitosa.
Al Tecnológico de Morelia y a todos mis profesores, realmente me siento
orgulloso de ser egresado de esta institución, gracias a ellos aprendí algo que
considero muy importante, “siempre estar aprendiendo cosas nuevas y por uno
mismo”, “siempre dar más de lo necesario”, aunque en su momento no
“agradecía” precisamente las noches de desvelo trabajando para esos
“proyectos semestrales” ahora que formo parte de productiva de la sociedad
agradezco mucho todo lo que aprendí tanto en las aulas, como en las
incontables horas de trabajo fuera de la institución.
Dedico este trabajo a mi familia.

INTRODUCCIÓN
En el siguiente material se estudian los temas de la asignatura de
Programación II del plan 2004 de la licenciatura en Informática.
Todos los temas se desarrollan utilizando el lenguaje de programación Java;
pero, debido a la temática que se debe contemplar para respetar el programa,
algunos de los temas deben explicarse con otras herramientas como Visual
Basic. Sin embargo se hace una pequeña comparación entre lo que pide el
programa y el equivalente en lenguaje java.
El material comienza desde lo más básico del lenguaje: comentarios,
declaraciones, sintaxis, etc. Y avanza hasta el punto de almacenamiento en
bases de datos.
El flujo de trabajo es el siguiente: se comienza a trabajar en modo consola, con
algoritmos sencillos y almacenamiento en memoria, a partir del final de la
primera unidad se comienzan a analizar objetos gráficos y en la segunda
unidad se trabaja absolutamente en ambiente gráfico, aún utilizando como
modo de almacenamiento la memoria de la PC. Después, a partir de la tercera
unidad, el modo de almacenamiento cambia a “Archivos” y se pide al
estudiante, programe aplicaciones gráficas almacenando y extrayendo
información de archivos de texto plano. Finalmente, el modo de
almacenamiento cambia a “Bases de Datos” y se analizan ejemplos sencillos
con bases de datos muy simples. Al final del material y a modo de información
extra se analiza cómo crear tus propios controles ActiveX con Visual Basic.
Los ejercicios propuestos para cada unidad pretenden reforzar los temas vistos
en cada una de las mismas y están diseñados de tal manera que el alumno
siga la línea de aprendizaje descrita en el párrafo anterior procurando siempre
que inculcar en el alumno la necesidad de investigar más y profundizar más en
los temas que se analizan. Los ejemplos siguen la misma línea de aprendizaje,
todos los ejemplos están relacionados con una aplicación y situación inicial a la
cual se le va agregando funcionalidad de acuerdo al avance en el temario de la
materia.
Finalmente, se incluye un glosario de términos que ayude al estudiante a
disipar dudas sobre tecnicismos que desconozca y se provee de una completa
bibliografía, describiendo en las ligas de internet el tipo de material que se
puede localizar en cada una. Cabe mencionar que dicha bibliografía se revisó
recientemente para confirmar la existencia actual de las mismas.

ITM INDICE GENERAL
INDICE
INTRODUCCION . . . . . . . . . . . . . . . . . i
UNIDAD I. “FUNDAMENTOS DEL LENGUAJE”
1.1 Programación orientada a eventos. . . . . . . . . . . 2
1.1.1 Objetos. . . . . . . . . . . . . . . . 2
1.1.2 Eventos. . . . . . . . . . . . . . . . 6
1.1.3 Métodos. . . . . . . . . . . . . . . . 10
1.1.4 Propiedades. . . . . . . . . . . . . . . 13
1.2 Entorno integrado de desarrollo. . . . . . . . . . . . 15
1.3 Ventanas (proyecto, propiedades, ayuda). . . . . . . . . 18
1.4 Tipos de proyectos. . . . . . . . . . . . . . . 23
1.4.1 Configuración. . . . . . . . . . . . . . .
23
1.5 Comentarios. . . . . . . . . . . . . . . . . 24
1.6 Constantes. . . . . . . . . . . . . . . . . 25
1.7 Tipos de datos. . . . . . . . . . . . . . . . . 26
1.8 Variables. . . . . . . . . . . . . . . . . . 32
1.9 Operadores. . . . . . . . . . . . . . . . . 36
1.10 Sentencias. . . . . . . . . . . . . . . . . 45
1.11 Matrices. . . . . . . . . . . . . . . . . . 46
1.12 Procedimientos y funciones.. . . . . . . . . . . . 49
1.13 Estructuras de control. . . . . . . . . . . . . . 55
1.14 Controles básicos y sus propiedades. . . . . . . . . 64
Ejercicios Propuestos. . . . . . . . . . . . . . . 72
Proyectos integrales. . . . . . . . . . . . . . . . 75
UNIDAD 2. “CONTROLES, EVENTOS, MÉTODOS Y COMPONENTES”
2.1 Controles estándar. . . . . . . . . . . . . . . 77
2.2 Eventos del formulario. . . . . . . . . . . . . . .
87
2.3 Cajas de diálogo. . . . . . . . . . . . . . . 93
2.3.1 Modales y no modales. . . . . . . . . . . 94
2.3.2 Predefinidas. . . . . . . . . . . . . . . 97
2.4 Componentes estándar. . . . . . . . . . . . . . 101
Ejercicios Propuestos. . . . . . . . . . . . . . . . 105
Proyecto integral . . . . . . . . . . . . . . . . 107
UNIDAD 3. “SISTEMAS DE ARCHIVOS”
3.1 Acceso secuencial. . . . . . . . . . . . . . . 111
3.2 Acceso directo. . . . . . . . . . . . . . . . . 115
3.3 Manejo de archivos. . . . . . . . . . . . . . . 122
3.4 Controlar errores en tiempo de ejecución. . . . . . . . . 130
Ejercicios Propuestos. . . . . . . . . . . . . . . . 133

ITM INDICE GENERAL
UNIDAD 4. “ACCESO A DATOS”
4.1 Introducción. . . . . . . . . . . . . . . . . 138
4.2 Control de datos ADO.. . . . . . . . . . . . . . 154
4.3 Objetos ADO. . . . . . . . . . . . . . . . . 156
4.4 Herramientas de acceso a datos. . . . . . . . . . . 164
4.4.1 ADO.NET . . . . . . . . . . . . 165
4.4.2 JDBC . . . . . . . . . . . . . . 165
4.4.3 ODBC . . . . . . . . . . . . . . 165
4.4.2 DAO . . . . . . . . . . . . . . 166
UNIDAD 5. “COMPONENTES Y CONTROLES DEFINIDOS POR EL USUARIO”
5.1 Modelo de componentes. . . . . . . . . . . . . 175
5.2 Crear un componente Active X. . . . . . . . . . . . 175
5.3 Crear un Control Active X. . . . . . . . . . . . . 177
Apéndice 1 Instalación de Net Beans. . . . . . . . . . . . . 187
Apéndice 2 Introducción a MySQL. . . . . . . . . . . . . . 191
Conclusiones. . . . . . . . . . . . . . . . . . . . 202
Bibliografía. . . . . . . . . . . . . . . . . . . . . 204
Glosario de Términos. . . . . . . . . . . . . . . . . . 209

ITM INDICE GENERAL
INDICE DE FIGURAS
UNIDAD I. “FUNDAMENTOS DEL LENGUAJE”
1.1 Ejemplo de cómo identificar Objetos. . . . . . . 3
1.2 Ejemplo de cómo identificar Objetos, Misma Clase. . . . . . 3
1.3 Ejemplo utilizando JOptionPane. . . . . . . . . . . 9
1.4 Ejemplo usando ventanas para entrada de datos.. . . . . . 9
1.5 Objeto en NetBeans. . . . . . . . . . . . . . . 13
1.6 Botón con texto editado. . . . . . . . . . . . . . 14
1.7 Pantalla principal de NetBeans 6.0. . . . . . . . . . . 16
1.8 Ventana de Proyectos.. . . . . . . . . . . . . . 18
1.9 Ventana elegir nombre y ubicación. . . . . . . . . . . 19
1.10 Hola Mundo en Java. . . . . . . . . . . . . . 20
1.11 Ventana Propiedades. . . . . . . . . . . . . 21
1.12 Ventana Help. . . . . . . . . . . . . . . . 21
1.13 Búsqueda en Ayuda. . . . . . . . . . . . . . 22
1.14 Ventana Proyectos.. . . . . . . . . . . . . . 24
1.15 Ejemplo de una etiqueta. . . . . . . . . . . . . 65
1.16 Ejemplo de ScrollBar no a la vista. . . . . . . . . . 70
1.17 Ejemplo de ScrollBar a la vista. . . . . . . . . . . 71
UNIDAD 2. “CONTROLES, EVENTOS, MÉTODOS Y COMPONENTES”
2.1 Ventana “Nuevo Proyecto”. . . . . . . . . . . . . 77
2.2 Ventana de configuración de proyecto. . . . . . . . . 78
2.3 Área de trabajo de NetBeans. . . . . . . . . . . 78
2.4 Aplicación de escritorio vacía. . . . . . . . . . . 79
2.5 Paleta de controles. . . . . . . . . . . . . . . 79
2.6 Programa en ejecución con botones de ejemplo. . . . . . . 80
2.7 Ventana Propiedades. . . . . . . . . . . . . . . 81
2.8 Cambio de propiedades de un objeto. . . . . . . . . . 82
2.9 Cambio de propiedad “name”. . . . . . . . . . . . 83
2.10 Programa en ejecución con caja de texto. . . . . . . 83
2.11 Cambio de Propiedades de un objeto Textfield. . . . . . . 84
2.12 Cambio de Propiedades de objetos CheckBox.. . . . . . 85
2.13 Aplicación con botones de opción. . . . . . . . . 87
2.14 Lista de eventos. . . . . . . . . . . . . . . . 88
2.15 Ejemplo en ejecución. . . . . . . . . . . . . . 89
2.16 Programa en ejecución. . . . . . . . . . . . . 90
2.17 Aplicación en ejecución. . . . . . . . . . . . . 92
2.19 Ventana “New File” crear caja de diálogo. . . . . . . . 95
2.20 Nuevo formulario para caja de diálogo vacio. . . . . . . 95

ITM INDICE GENERAL
2.22 Cómo ver la lista de cuadros de diálogo predefinidos. . . . 98
2.23 Error por no importar librería. . . . . . . . . . . . 98
2.24 Herramienta útil para corregir errores sencillos. . . . . . . 99
2.27 Componentes Swing y AWT. . . . . . . . . . . . 102
UNIDAD 3. “SISTEMAS DE ARCHIVOS”
3.1 Programa en ejecución. . . . . . . . . . . . . . 113
3.2 Programa en ejecución. . . . . . . . . . . . . . 115
3.3 Ejemplo con RandomAccessFile. . . . . . . . . . . 119
3.4 Ejemplo usando JFileChooser. . . . . . . . . . . . 123
3.5 Selector de apertura. . . . . . . . . . . . . . . 123
3.6 Selector personalizado. . . . . . . . . . . . . . 125
UNIDAD 4. “ACCESO A DATOS”
4.1 Ventana: elegir nombre de página y puerto. . . . . . . . 140
4.2 Ventana: configuración de MySQL. . . . . . . . . . . 140
4.3 Iniciar ambos servidores. . . . . . . . . . . . . . 141
4.4 Pantalla principal del servidor Apache. . . . . . . . . 141
4.5 Pantalla principal de phpMyAdmin. . . . . . . . . . . 142
4.6 ¿Cómo acceder a la tabla de Usuarios?. . . . . . . . . 143
4.7 Consulta de la tabla “user” de MySQL. . . . . . . . . . 143
4.8 Datos a llenar para dar de alta otro usuario. . . . . . . . .
144
4.9 ¿Cómo agregar el driver para conectar…?. . . . . . . . .
145
4.10 Ventana: agregar driver JDBC. . . . . . . . . . . . 145
4.11 Opción para conectar la base de datos. . . . . . . . . 146
4.12 Agregar los datos a la Base de datos. . . . . . . . . 146
4.13 Conectar NetBeans con MySQL. . . . . . . . . . . 147
4.14 Ventana: Conexión establecida. . . . . . . . . . . 147
4.15 Ejemplo de botó que invoca una conexión. . . . . . . 149
4.16 Opción necesaria para crear una Base de Datos. . . . . . 150
4.17 Crear tablas de la base de datos. . . . . . . . . . . 151
4.18 Ingresar datos de la tabla. . . . . . . . . . . . . 151
4.19 Ingresar datos de cada campo de la tabla. . . . . . . . .
152
4.20 Vista de las tablas de nuestra nueva base de datos. . . . . 152
4.22 Contenido de la base de datos. . . . . . . . . . . 154
UNIDAD 5. “COMPONENTES Y CONTROLES DEFINIDOS POR EL USUARIO”
5.1 Tipos de proyectos en Visual Basic.. . . . . . . . . . 178
5.2 Propiedades del Proyecto. . . . . . . . . . . . . 179

ITM INDICE GENERAL
5.3 Evento “resize” del control ActiveX. . . . . . . . . . . 180
5.4 Ventana para activar el asistente de configuración. . . . . . 180
5.5 Ventana: Seleccionar miembros de la interfaz. . . . . . . 181
5.6 Ventana: Agregar miembros personalizados. . . . . . . . 181
5.7 Ventana crear miembros personalizados de la interfaz. . . . . 182
5.8 Ventana: establecer atributos de los miembros. . . . . . . 182
5.9 Utilización de nuestro control.. . . . . . . . . . . . 184
5.10 Objeto Active X. . . . . . . . . . . . . . . . 186

Unidad 1. Fundamentos del
Lenguaje.
Conceptos básicos.

ITM Unidad I Fundamentos del Lenguaje
1.1 Programación Orientada A Eventos
1.1.1 Objetos
Un objeto es una entidad provista de un conjunto de propiedades o atributos
(datos) y de comportamiento o funcionalidad (métodos). Corresponden a los
objetos reales del mundo que nos rodea, o a objetos internos del sistema (del
programa). Es una instancia de una clase.
Los objetos son entidades que combinan estado, comportamiento e identidad.
El estado está compuesto de datos, y el comportamiento por procedimientos o
métodos. La identidad es una propiedad de un objeto que lo diferencia del
resto. La programación orientada a objetos expresa un programa como un
conjunto de estos objetos, que colaboran entre ellos para realizar tareas. Esto
permite hacer los programas y módulos más fáciles de escribir, mantener y
reutilizar.
De esta forma, un objeto contiene toda la información que permite definirlo e
identificarlo frente a otros objetos pertenecientes a otras clases e incluso frente
a objetos de una misma clase, al poder tener valores bien diferenciados en sus
atributos. A su vez, los objetos disponen de mecanismos de interacción
llamados métodos que favorecen la comunicación entre ellos. Esta
comunicación favorece a su vez el cambio de estado en los propios objetos.
Esta característica lleva a tratarlos como unidades indivisibles, en las que no se
separan ni deben separarse el estado y el comportamiento.
Identificando objetos
• Los objetos pueden ser físicos o conceptuales.
Una cuenta de cliente es un ejemplo de un objeto conceptual
porque no se puede tocar físicamente. Un cajero automático es
algo que mucha gente toca todos los días y es un ejemplo de un
objeto físico.
• Los objetos tienen atributos (características).
Tal como tamaño, nombre, color, forma, etc. Los valores de los
atributos son referidos como el estado actual del objeto. Por
ejemplo, un objeto puede tener un atributo color con el valor de
rojo.
• Los objetos tienen operaciones (las cosas que pueden hacer).

Tal como asignar un valor, desplegar una pantalla, o incrementar
rapidez. Las operaciones usualmente afectan los atributos de los
objetos.
! "# $ % # &
Otro ejemplo seria una puerta… Sus atributos serian el color, tamaño, material,
etc. Sus operaciones o métodos serian cerrar_puerta(), abrir_puerta().
El identificar objetos ayuda a diseñar las clases (o plantillas) para cada tipo de
objetos en un sistema. En la Programación Orientada a Objetos (POO) cada
objeto de una clase es llamada una instancia de clase y tiene valores distintos
en sus atributos, pero son los mismos atributos y las mismas operaciones.
' $ "# & % # &( ) & &
Para declarar un objeto, primero debemos declarar la clase, la sintaxis en Java
es la siguiente:
Declaración de clases:
En Java la declaración de clases toma la siguiente forma:
<modificador>* class <nombre_clase> {
<declarer_atributos>*
<declarar_constructor>*
<declarar_métodos>*

}
Ejemplo: En el archivo MiClase.class
package javaApplication1;
public class MiClase{
String mensaje;
}
Declaración de objetos:
Para declarar un objeto se sigue la siguiente sintaxis:
<nombre_clase> <nombre_objeto> = new <nombre_clase>();
Ejemplo: En el archivo Main.class
package javaApplication1;
public class Main {
public static void main(String[] args) {
//variable usada para explicar la herencia.
int i=0;
//Aquí se crea el objeto
MiClase imprimir=new MiClase();
imprimir.mensaje=”Hola a todos”;
System.out.println("El mensaje es: " +
imprimir.mensaje);
}
}
Si corremos el archivo MiClase.class, la salida será: “El mensaje es: Hola a
todos”. Ambos archivos deberán contenerse en una aplicación creada dentro
de NetBeans, este proceso se explicara con detalle posteriormente. A grandes
rasgos, deberá ir al menú “file”, seleccionar “New Project” aparecerá la
ventana de las diferentes categorías, seleccionamos la categoría “Java” y
dentro de ella la opción “Java Application” el nombre del archivo Main.class
dentro del proyecto.
Una vez que tenemos nuestro proyecto, iremos al menú “file”, seleccionamos
la opción “New File”, en el campo “Categories” seleccionamos “Java” y en el
campo “File Types” seleccionamos “Java Class” en el caso del ejemplo la
clase se llama MiClase, debido a ello así se llama el archivo. Con esto
tendremos nuestros dos archivos creados y listos para introducir nuestro
código.
Proyecto: Durante el desarrollo de esta unidad se irán planteando ejercicios,
todos los ejercicios serán parte de un proyecto en el cual se tendrá como
resultado el uso de todas las herramientas que se analizarán durante el
desarrollo de la Unidad I.

Ejercicio 1.1: Inicie un proyecto en NetBeans, una aplicación normal (No de
escritorio) Esto creará a su clase principal. Ahora declare una clase, esta clase
será nuestra clase base en el proyecto y se llamará “Operaciones”, si lo desea
puede poner el nombre que desee pero posteriormente estaremos referencia a
esta clase con el nombre aquí propuesto, la clase Operaciones deberá
contener una variable para almacenar los resultados de las operaciones.
Herencia
La herencia es uno de los aspectos de la programación orientada a objetos que
se ha definido formalmente. Utilizando la herencia, se puede derivar una nueva
clase a partir de una antigua. La clase nueva se llama clase derivada y la clase
original, clase base. La idea es añadir lo que se quiera a la nueva clase para
darle más funcionalidad a la clase base.
La herencia es el mecanismo por el que se crean nuevos objetos definidos en
términos de objetos ya existentes. Por ejemplo, si se tiene la clase Ave, se
puede crear la subclase Pato, que es una especialización de Ave.
class Pato extends Ave {
int numero_de_patas;
}
La palabra clave extends se usa para generar una subclase (especialización)
de un objeto. Un Pato es una subclase de Ave. Cualquier cosa que contenga la
definición de Ave será copiada a la clase Pato. Además, en Pato se pueden
definir sus propios métodos y variables de instancia. Se dice que Pato deriva o
hereda de Ave.
La sintaxis para declarar una clase derivada es similar a la de una clase
normal, únicamente debemos agregar la palabra reservada extends seguida
del nombre de la clase base.
<modificador>* class <nombre_clase> extends <nombre_clase_base>{
<declarer_atributos>*
<declarar_constructor>*
<declarar_métodos>*
}
Además, se pueden sustituir los métodos proporcionados por la clase base.
Utilizando nuestro el ejemplo de MiClase, aquí hay un ejemplo de una clase
derivada aumentando a la función Suma_a_i():

import MiClase;
public class MiNuevaClase extends MiClase {
public void Suma_a_i( int j ) {
i = i + ( j/2 );
}
}
Ahora cuando se crea una instancia de MiNuevaClase, esta contendrá todas
las características de la clase MiClase y además podrá utilizar el método
Suma_a_i(), de ahí que podamos utilizar la variable “i” sin haberla declarado
aquí. Debido a que se esta heredando de MiClase, MiNuevaClase puede hacer
uso de ella.
En Java no se puede hacer herencia múltiple. Por ejemplo, de la clase aparato
con motor y de la clase animal no se puede derivar nada, sería como obtener el
objeto toro mecánico a partir de una máquina motorizada (aparato con motor) y
un toro (animal). En realidad, lo que se pretende es copiar los métodos, es
decir, pasar la funcionalidad del toro de verdad al toro mecánico, con lo cual no
sería necesaria la herencia múltiple sino simplemente la compartición de
funcionalidad que se encuentra implementada en Java a través de interfaces.
Ejercicio 1.2: Defina cuatro clases que hereden las características de la clase
Operaciones. Las nuevas clases serán Suma, Resta, Multiplica y Divide. Hasta
este momento ninguna de nuestras clases posee métodos o propiedades.
1.1.2 Eventos
Un evento es un suceso en el sistema (tal como una interacción del usuario con
la máquina, o un mensaje enviado por un objeto). El sistema maneja el evento
enviando el mensaje adecuado al objeto pertinente. También se puede definir
como evento, a la reacción que puede desencadenar un objeto, es decir, la
acción que genera.
Los lenguajes visuales orientados a eventos y con manejo de componentes
dan al usuario que no cuenta con mucha experiencia en desarrollo, la
posibilidad de construir sus propias aplicaciones utilizando interfaces gráficas
sobre la base de ocurrencia de eventos.
Para soportar este tipo de desarrollo interactúan dos tipos de herramientas, una
que permite realizar diseños gráficos (En nuestro caso NetBeans) y, un
lenguaje de alto nivel que permite codificar los eventos (Java). Con dichas
herramientas es posible desarrollar cualquier tipo de aplicaciones basadas en
el entorno.
Java es uno de los lenguajes de programación que más entusiasmo despiertan
entre los programadores, tanto expertos como novatos. En el caso de los
programadores expertos por la facilidad con la que desarrollan aplicaciones

complejas en poquísimo tiempo. En el caso de los programadores novatos por
el hecho de ver de lo que son capaces a los pocos minutos de empezar su
aprendizaje.
Java es también un lenguaje orientado a objetos. La diferencia con un lenguaje
no orientado a objetos y uno basado en objetos es que el segundo utiliza
objetos con propiedades y métodos, pero carece de los mecanismos de
herencia y polimorfismo propios de los verdaderos lenguajes orientados a
objetos como Java.
Existen distintos tipos de programas. Al inicio de la historia de la programación
los programas eran de tipo secuencial (también llamados tipo batch). Un
programa secuencial es un programa que se arranca, lee los datos que
necesita, realiza los cálculos e imprime o guarda en el disco los resultados.
Mientras un programa secuencial está ejecutándose no necesita ninguna
intervención del usuario. A este tipo de programas se les llama también
programas basados u orientados a procedimientos o a algoritmos (procedural
languages). Este tipo de programas siguen utilizándose ampliamente en la
actualidad, pero la difusión de las PC’s ha puesto de actualidad otros tipos de
programación.
Los programas interactivos exigen la intervención del usuario en tiempo de
ejecución, ya sea para suministrar datos, o bien para indicar al programa lo
que debe hacer por medio de menús. Los programas interactivos limitan y
orientan la acción del usuario.
Por su parte los programas orientados a eventos son los programas típicos de
Windows, tales como Netscape, Word, Excel, PowerPoint y otros. Cuando uno
de estos programas ha arrancado, lo único que hace es quedarse a la espera
de las acciones del usuario, que en este caso son llamadas eventos.
El usuario dice si quiere abrir y modificar un archivo existente, o bien comenzar
a crear un archivo desde el principio. Estos programas pasan la mayor parte de
su tiempo esperando las acciones del usuario (eventos) y respondiendo a ellas.
Las acciones que el usuario puede realizar en un momento determinado son
variadísimas, y exigen un tipo especial de programación: la programación
orientada a eventos. Este tipo de programación es sensiblemente más
complicada que la secuencial y la interactiva, pero con los lenguajes visuales
de hoy, se hace sencilla y agradable.
Ya se ha dicho que las acciones del usuario sobre el programa se llaman
eventos. Son eventos típicos el clic sobre un botón, el hacer doble clic sobre el
nombre de un archivo para abrirlo, el arrastrar un icono, el pulsar una tecla o
combinación de teclas, el elegir una opción de un menú, el escribir en una caja
de texto, o simplemente mover el ratón.
Cada vez que se produce un evento sobre un determinado tipo de control,
NetBeans arranca una determinada función o procedimiento que realiza la
acción programada por el usuario para ese evento concreto. Estos

procedimientos se llaman con un nombre que se forma a partir del nombre del
objeto y el nombre del evento como se muestra a continuación:
private void botonAbrirMouseClicked
(java.awt.event.MouseEvent evt) {
// TODO add your handling code here:
}
Como se puede observar, el evento que se programará es el clic sobre el
objeto botonAbrir, cabe mencionar que al utilizar NetBeans, todo este código se
generará automáticamente. Lo único que tendremos que hacer será
seleccionar el objeto que deseamos, seleccionar un evento de la pestaña de
eventos y dar doble clic. El programa incluso coloca comentarios en el código
para guiarnos. Por ejemplo en el evento anterior, se nos indica donde podemos
colocar nuestro código. Este proceso se explica con mayor detalle adelante.
Para comprender más sobre los eventos tenemos el siguiente ejemplo. Solo se
muestra un mensaje de confirmación. Para ello se utiliza la clase JOptionPane,
esta clase se analiza a fondo en la unidad II.
Ejemplo: Hacer un pequeño ejemplo en el cual se muestre un pequeño
mensaje de bienvenida. El código es el siguiente:
package proyecto;
import javax.swing.JOptionPane;
/**
*
* @author saul.chavez
*/
public class Main {
/**
* @param args the command line arguments
*/
JOptionPane.showMessageDialog(null,
"Bienvenido al lenguaje Java");
System.Out.Println(Bienvenido al lenguaje Java”
}
}
El código anterior es tal cual un nuevo proyecto en NetBeans. Para el ejemplo
anterior no se tuvo más que crear nuevo proyecto y agregar las líneas en
negrita que se encarga de mostrar el mensaje deseado, que es todo lo que
hace el programa. Con JOptionPane se crea una ventana como la que se

muestra en la Figura 1.3. Con System.Out.Println(); el mensaje se
muestra en modo texto.
* # + " , # " "
Hay otro tipo de ventana de diálogo predefinida que necesitaremos conocer en
este momento para los ejercicios propuestos. Esta ventana nos servirá para
introducir datos gráficamente y se utiliza de la siguiente manera:
package proyecto;
import javax.swing.JOptionPane;
JOptionPane.showMessageDialog(null,
"Bienvenido al lenguaje Java");
int Valor = Integer.parseInt
(JOptionPane.showInputDialog(null, "Introduce un valor"));
}
}
Lo que se está haciendo en la línea en negritas es declarar una variable entera,
mostrar una venta de diálogo que pide un valor y asignarlo a la variable. La
instrucción sola que muestra la ventana deseada es:
! " # ! $ % & ' '(
Pero esto nos regresa una cadena, no un entero. Por ello utilizamos el método
Integer.ParseInt(); que transforma la cadena que reciba en un valor entero. Si
se recibe como parámetro una cadena que no representa a un valor entero
(como “hola” en lugar de “200”) se producirá un error en al método ParseInt().
- & " . "# " & / "# # &
) ) *

)+
Los métodos son funciones de una clase. Generalmente los métodos se
dividen en aquellos que se usan internamente en la clase, llamados métodos
privados (private), los que se usan fuera de la clase, llamados métodos
públicos (public) y los que son usados por la clase y sus derivadas, llamados
métodos protegidos (protected).
Los métodos privados son generalmente llamados en el interior del objeto por
otras partes del mismo.
Una vez que se tiene un objeto que soporta métodos, se pueden usar los
métodos de esos objetos. En el ejemplo siguiente se usa el método calcular
para trabajar con los valores de operando1 y operando2 y almacenar el
resultado en la variable resultado.
//Suponiendo que ya creamos esta clase
Calculadora objeto = new Calculadora();
double resultado = objeto.calcular(operando1, operando2);
//Suponiendo que el método calcular también fue
programado.
Java soporta dos tipos de métodos: métodos de clase y métodos de instancia.
Los métodos de instancia, como en el ejemplo “calcular”, son invocados en
objetos (es decir, los objetos son instancias de una clase). Los métodos de
clase, por otro lado, son invocados en una clase. Por ejemplo, la clase
java.lang.Math tiene un método de clase llamado sqrt que calcula una raíz
cuadrada y se puede usar como sigue (no es necesario un objeto):
public static void main (String [] args)
double valor = 4, raiz;
raiz = Math.sqrt(valor);
System.out.println(“La raíz cuadrada de “ +
valor + “ = “ + sqrt);
}
}
La salida de este código es:
La raíz cuadrada de 4.0 = 2.0
Ejercicio 1.3: Defina en cada una de las clases de su proyecto, un método que
realice la operación a la que su nombre hace referencia (Ej. En la clase Suma
un método que sume). Cada método trabajará únicamente con dos operadores,
los cuales se recibirán como parámetros cuando una instancia de la clase los

))
requiera. Utilice la clase JOptionPane ejemplificada anteriormente para obtener
los valores.
Método main
Es un método especial que java reconoce como el punto inicial para que un
programa se ejecute desde la línea de comando. Su sintaxis es:
public static void main (String args[]){
//Código}
Siempre debe tener dos modificadores de acceso: public y static. El método
main no regresa ningún valor. Acepta cero o más objetos de tipo String.
Accesando miembros del objeto
El operador punto (.) permite accesar a atributos y métodos no privados
de una clase como se muestra en los ejemplos anteriores.
Dentro de un método no se necesita usar esta notación para accesar
miembros locales del método.
Generalmente se crean métodos set() y get() para accesar a miembros
de un objeto que no es local.
Polimorfismo
El polimorfismo se logra mediante la sobrecarga de métodos. Consiste en crear
métodos que se comporten de manera distinta dependiendo de los parámetros
con los que trabaje. Por ejemplo, si usted crea una clase cualquiera y en ella
define el método “Suma”, el cual realiza la suma de dos operadores, pero usted
tiene la necesidad de sumar ahora tres operadores… No necesita crear un
nuevo método para realizar dicha acción, para eso sirve la sobrecarga de
métodos.
La sobrecarga de métodos permite definir diferentes versiones de un método,
todos con el mismo nombre pero con diferentes listas de parámetros. Cuando
se utiliza un método sobrecargado, el compilador de java sabe cual se desea
utilizar por el número y/o tipo de parámetros que se le pasen.
Para sobrecargar un método, sólo hay que definirlo más de una vez,
especificando una nueva lista de parámetros en cada una de ellas. Cada lista
de parámetros debe ser diferente de cualquier otra de alguna forma, el número
de parámetros o el tipo de uno o más de ellos.
Ejemplo: Sobrecargaremos el método Suma de la clase Calculadora

)
//Clase original sin sobrecarga.
class Calculadora
{
int Suma(int op1, int op2)
{
return op1 + op2;
}
}
Para utilizar la clase anterior el código es el siguiente.
public static void main(String [] args){
Calculadora calc = new Calculadora();
System.out.println(“Suma 2 más 2 = “ +
calc.Suma(2,2));
System.out.println(“Suma 2 más 2 más 2 = “ +
calc.Suma(2,2,2));
}
}
Como puede ver, la sobrecarga proporciona una técnica potente, con ella
podemos evitar problemas clásicos de desorden de código como la declaración
de varios métodos con nombres como: “Suma2”, “Suma3” o “SumaDosOp”,
“SumaTresOp”, etc.
Ejercicio 1.4: Sobrecargue cada uno de los métodos que contienen las clases
Suma, Resta, Multiplica y Divide para que trabajen con tres operadores de la
siguiente manera:
*Suma: Se sumarán los tres operadores.
*Resta: el tercer parámetro indicara cuantas veces se desea que se reste el
segundo parámetro al primero.
class Calculadora
{
//método Suma que trabaja con dos operadores
int Suma(int op1, int op2)
{
return op1 + op2;
}
//método Suma que trabaja con tres operadores
int Suma(int op1, int op2, int op3)
{
return op1 + op2 + op3;
}
}

)
*Multiplica: Se multiplicarán los tres parámetros entre sí.
*Divide: El tercer parámetro indicará cuantas veces se desea que se divida el
primer parámetro entre el segundo.
Los resultados de las operaciones deberán ser manipulados o almacenados en
la variable que contiene la clase Operaciones para que la herencia tenga algún
sentido y mostrados al usuario por medio de ventanas de diálogo (Utilice la
clase JOptionPane para esto).
1.1.4 Propiedades
Una propiedad es una asignación que describe algo sobre un objeto como un
formulario, un botón, una lista, etc. Dependiendo de la propiedad, se le puede
asignar en tiempo de diseño usando la ventana Propiedades y/o en tiempo de
ejecución al programar.
Los objetos que ya existen en NetBeans como los botones, listas, formularios,
etc. Tienen propiedades definidas ya en el lenguaje, por ejemplo:
0 % # " 1 # "&
Un botón en NetBeans como este posee propiedades como:
Font: describe el tipo de letra que contiene el botón.
Background: indica el color del fondo del botón.
Name: nombre del objeto asignado por el usuario.
Como estas propiedades, cada objeto en NetBeans posee sus propiedades
específicas, estas propiedades pueden ser modificadas dentro del ambiente
grafico de NetBeans en la ventana de propiedades (Los aspectos relacionados
con el funcionamiento gráfico serán analizados a profundidad posteriormente) o
en el código escribiendo el nombre del objeto seguido de un punto.
(<Nombre_objeto>.<Propiedad>), al escribir el punto (.) NetBeans nos mostrará
una lista de las propiedades y los métodos del objeto.
Ejemplo: si queremos cambiar el texto jButton1 que se encuentra en el botón,
utilizamos el método “setText(“String”).
jButton1.setText(“Hola”);
2 #!" " # 3# #
En caso de que se trate de objetos creados por nosotros mismos como se
mostró en la parte “1.1.1 Objetos” de este libro, las propiedades son descritas

)
por los atributos. En Java, los atributos son representados usando variables
(estas a su vez son el mecanismo para guardar datos)
Declaración de atributos
<modificador>* <tipo> <nombre> [=<valor_inicial>];
Ejemplo:
int x;
private float y = 10000.0F;
public String name = “Saúl Chávez”;
…
La palabra private indica que el atributo solo es accesible por los métodos
dentro de la clase. El tipo puede ser primitivo o de cualquier clase.
Por último, al igual que para los atributos de los objetos de NetBeans, para
accesar a las propiedades de un objeto se utiliza el operador punto (.).
Ejemplo:
MiClase objeto1 = new MiClase(); //Declaramos el objeto
objeto1.x=30;
//asignamos un valor al atributo x del objeto
Modificadores de acceso
Los modificadores de acceso permiten al diseñador de una clase determinar
quien accede a los datos y métodos miembros de una clase.
Los modificadores de acceso preceden a la declaración de un elemento de la
clase (ya sea dato o método), de la siguiente forma:
[modificadores] tipo_variable nombre;
[modificadores] tipo_devuelto nombre_Metodo ( lista_Argumentos );
Existen los siguientes modificadores de acceso:
• public - Todo el mundo puede acceder al elemento. Si es un dato, todo
el mundo puede ver el elemento, es decir, usarlo y asignarlo. Si es un
método todo el mundo puede invocarlo.
• private - Sólo se puede acceder al elemento desde métodos de la clase,
o sólo puede invocarse el método desde otro método de la clase.

)
• protected – Es más accesible que prívate debido a que permite el uso a
todos los elementos de la clase o clases derivadas. Se explicará mas a
detalle en el tema de la herencia.
• sin modificador - Se puede acceder al elemento desde cualquier clase
del package donde se define la clase.
Pueden utilizarse estos modificadores para cualquier tipo de miembros de la
clase, incluidos los constructores (con lo que se puede limitar quien puede
crear instancias de la clase).
1.2 Entorno Integrado De Desarrollo
Un entorno de desarrollo integrado o en inglés Integrated Development
Environment (IDE1
) es un programa compuesto por un conjunto de
herramientas para un programador.
Puede dedicarse en exclusiva a un sólo lenguaje de programación o bien,
poder utilizarse para varios.
Un IDE es un entorno de programación que ha sido empaquetado como un
programa de aplicación, es decir, consiste en un editor de código, un
compilador, un depurador y un constructor de interfaz gráfica GUI2
. Los IDEs
pueden ser aplicaciones por si solas o pueden ser parte de aplicaciones
existentes. El lenguaje Visual Basic por ejemplo puede ser usado dentro de las
aplicaciones de Microsoft Office, lo que hace posible escribir sentencias Visual
Basic en forma de macros para Microsoft Word.
Los IDEs proveen un marco de trabajo amigable para la mayoría de los
lenguajes de programación tales como C++, Java, C#, Delphi, Visual Basic,
etc. Es posible que un mismo IDE pueda funcionar con varios lenguajes de
programación. Para conocer el proceso de instalación de NetBeans (que es el
IDE que se utilizará en esta obra) y algunos otros IDE´s consulte el Anexo 1.
NetBeans
"# " "# & 1 # "& 4 " 5 "# & 4 $ # " !"
'
6 5 7& "# $ "# $ + 6 /$ 7& 8 . & "# & 9 /$ "#
" &# & " & /$ & &# " % # " & % " # 9 & "# & " "
&4 " ( # :

)
; "# " 1 # "&
NetBeans se refiere a una plataforma para el desarrollo de aplicaciones de
escritorio usando Java y a un entorno de desarrollo integrado (IDE)
desarrollado usando la Plataforma NetBeans.
La plataforma NetBeans permite que las aplicaciones sean desarrolladas a
partir de un conjunto de componentes de software llamados módulos. Un
módulo es un archivo Java que contiene clases de java escritas para
interactuar con las APIs de NetBeans y un archivo especial (manifest file) que
lo identifica como módulo. Las aplicaciones construidas a partir de módulos
pueden ser extendidas agregándole nuevos módulos.
Debido a que los módulos pueden ser desarrollados independientemente, las
aplicaciones basadas en la plataforma NetBeans pueden ser extendidas
fácilmente por otros desarrolladores de software.
NetBeans es un proyecto de código abierto de gran éxito con una gran base de
usuarios, una comunidad en constante crecimiento. Sun MicroSystems3
fundó
el proyecto de código abierto NetBeans en junio 2000 y continúa siendo el
patrocinador principal de los proyectos.
La Plataforma NetBeans es una base modular y extensible usada como una
estructura de integración para crear aplicaciones de escritorio grandes.
Empresas independientes asociadas, especializadas en desarrollo de software,
proporcionan extensiones adicionales que se integran fácilmente en la
plataforma y que pueden también utilizarse para desarrollar sus propias
herramientas y soluciones.
*
" ) &<&# & & " & "$ /# " = <( $ % "# & " # & < & $#>

)
La plataforma ofrece servicios comunes a las aplicaciones de escritorio,
permitiéndole al desarrollador enfocarse en la lógica específica de su
aplicación. Entre las características de la plataforma están:
• Administración de las interfaces de usuario (ej. menús y barras de
herramientas).
• Administración de las configuraciones del usuario.
• Administración del almacenamiento (guardando y cargando cualquier
tipo de dato).
• Administración de ventanas.
• Framework basado en asistentes (diálogo paso a paso).
Está escrito en Java y existe además un número importante de módulos para
extender el IDE NetBeans. El IDE NetBeans es un producto libre y gratuito sin
restricciones de uso.
Paquetes adicionales de NetBeans.
Pack de Movilidad de NetBeans
El Pack de Movilidad de NetBeans es una herramienta para desarrollar
aplicaciones que se ejecutan en teléfonos móviles. El Pack de Movilidad puede
ser usado para escribir, probar, y depurar aplicaciones para la plataforma Java
ME4
, tecnología existente en dispositivos móviles.
Profiler de NetBeans
El Profiler de NetBeans es una herramienta para la optimización de
aplicaciones Java: Ayuda a encontrar cuellos de botella en la memoria y a
optimizar la velocidad de las aplicaciones.
El C/C++ Native Development Module
Soporta proyectos de C/C++. Más información:
http://www.netbeans.org/kb/55/1/cnd-index.html
-
, . ) , . ) # " ? "# & & < # & # " @ & . &

)
1.3 Ventanas (proyecto, propiedades, ayuda).
Ventana de proyectos
A = "# " < # &
Esta es la ventana de proyectos de NetBeans, para accesar a ella deberá dar
clic sobre el menú File (Archivo) y a continuación en New Project (Nuevo
Proyecto). Podrá seleccionar entre los distintos tipos de proyectos, desde
aplicaciones de consola, pasando por aplicaciones de escritorio, hasta
aplicaciones para celulares o páginas web. Los tipos de proyectos serán
analizados en el siguiente tema. (1.4 Tipos de proyectos), por ahora solo se
analizan los componentes de las ventanas en cuestión.
Como puede observar, esta ventana es muy sencilla, únicamente debe
seleccionar la categoría del proyecto que quiere crear y el tipo de proyecto
dentro de la categoría que eligió. Si no está seguro que tipo de proyecto debe
crear, esta ventana muestra una breve explicación de lo que hará en cada
caso en el campo “Description”, bastará con que usted seleccione una
categoría y un tipo de proyecto para que se muestre la descripción del mismo
en dicho campo.
Por ejemplo, podemos ver que se encuentra seleccionada la categoría “Java” y
el tipo de proyecto “Java Desktop Application” y debajo nos dice:
Crea un esqueleto de una aplicación de escritorio basada en la Swing
Application Framework. Este template provee infraestructura básica para
aplicaciones como barras de menú, persistencia de estado de ventana, y
barras de estado. Con este template, puedes además generar código para

)
crear una interfaz GUI (Interfaz Gráfica de Usuario) para una tabla de base de
datos.
Ejemplo: Crearemos un “Hola Mundo” en una aplicación Java. (Java
Application).
1. Seleccione la categoría “Java” y el proyecto “Java Application”.
2. De clic sobre el botón “Next”
3. Nos aparece la ventana de Nombre y Localización, esto se refiere
al nombre que tendrá nuestra aplicación y el lugar donde serán
guardados los archivos que se generen.
B = "# " " % % !"
4. Especificamos un nombre, en este caso HolaMundo. Este será el
nombre de nuestra clase principal y el archivo. Como se explicó
anteriormente, dentro de nuestro programa debe existir el método
main. NetBeans lo generará automáticamente.
5. Damos clic en “Finish”.
6. Como puede observar, se creó el método Main automáticamente,
incluso tenemos comentarios importantes acerca del código.
Habrá ocasiones en la que no podrá modificar el código generado
automáticamente debido a puede provocar un mal
funcionamiento. Bueno, pasamos a nuestro método main y

+
escribimos System.out.println("Hola Mundo"); donde se indica
que debemos colocar nuestro código.
7. Damos clic sobre el botón de correr proyecto o presionamos f6 y
veremos que sucede.
? ) " " .
Como puede ver, tenemos una pequeña ventana con el nombre de “Projects”,
esta nos muestra el proyecto en el que estamos trabajando y los archivos que
necesitamos. Entre esos archivos se encuentran las librerías que incluimos.
Ventana Propiedades
Para abrir la ventana de propiedades, damos clic sobre el menú “Window” y a
continuación en “Properties”.
Con esto se mostrará la ventana de propiedades de nuestra aplicación.
NetBeans lo conoce como Main.java aunque si lo buscamos en el directorio
que se creo, la clase principal se llamará HolaMundo.class.
En esta ventana podemos observar información como el nombre, el directorio
donde se encuentran los archivos, la hora a la que se modificaron y el directorio
donde se crean los archivos de clases que conforman a nuestro proyecto. Por
ejemplo el archivo HolaMundo.class.
C4 @ " & !
C4 @ & &# &
#!" < #

)
= "# " &
, -.
Para abrir la ventana de ayuda debe dar clic sobre el menú “Help” y a
continuación en “Help Contents”.
' = "# " ?

En esta ventana, podremos buscar información relacionada con temas
específicos listados del lado izquierdo en la ventana de contenido “Contents” o
buscar información dentro del contenido mediante algún criterio de búsqueda
en la pestaña de “Search” (esta es la más recomendada).
No hay ningún grado de dificultad en el uso de esta ventana. Si desea ver la
información de los temas listados, únicamente de clic sobre el tema que le
interesa, o si le interesa saber algo de algún tema especifico y no sabe en qué
tema pueda encontrarlo, utilice la búsqueda. Para ello únicamente debe
ingresar una palabra o palabras relacionadas con la información que usted
necesita y a continuación se le mostrará un listado de archivos en los que se
localizó el criterio de búsqueda. Por ejemplo, buscaremos la información
relacionada con un botón.
Cabe mencionar que NetBeans le permite ingresar su criterio de búsqueda en
el idioma requerido o no obtendrá resultados.
Buscar: Button
* D&4 " C<
En la figura 1.13 se muestra el resultado de la búsqueda.
1.4 Tipos De Proyectos.
1.4.1 Configuración

Como ya se mencionó, Se pueden crear muchos tipos de proyectos de cada
categoría en NetBeans, de entre los cuales:
Categoría Java
Java Application: crea una aplicación en un proyecto estándar de la IDE. Puede
generarse la clase main en el proyecto. El proyecto que creamos en esta
primera unidad es de este tipo.
Java Desktop Application: crea un esqueleto de una aplicación de escritorio
basada en la Swing Application Framework (JSR 296). Este template provee
infraestructura básica para aplicaciones como barras de menú, persistencia de
estado de ventana, y barras de estado. Con este template, puedes además
generar código para crear una interfaz GUI (Interfaz Gráfica de Usuario) para
una tabla de base de datos.
Java Class Library: Crea una librería Java SE (Standard Edition) en un
proyecto estándar IDE (Entorno Integrado de Desarrollo). No contiene clase
main.
Java Project with Existing Sources: importa una aplicación existente de java
para crear un proyecto estándar IDE. La aplicación de java se puede importar
de múltiples folders.
Categoría Web
Web Application: Crea una aplicación web vacía en un proyecto IDE estándar.
Web Application with Existing Sources: importa una aplicación web existente
para crear un proyecto IDE estándar.
Como existen muchos proyectos posibles, no se explicará cada uno pero en la
ventana de nuevo proyecto existe una pequeña parte, en la cual se describe
qué clase de proyecto se creará de acuerdo a la opción y la categoría
seleccionadas.

- = "# " < # &
1.5 Comentarios
En muchas ocasiones, es necesario incluir notas en el código para documentar
un poco y recordar posteriormente para que se utiliza una función u
alguna línea de código, para poder hacer esto existen los comentarios:
• Comentarios de una sola línea.
• Comentarios de una o más líneas.
Ejemplos:
// Comentarios para una sola línea (doble diagonal).
/* Comentarios de una o más líneas, (diagonal-asterisco
para iniciar le comentario, asterisco-diagonal para
terminarlo.*/
/** Comentario de documentación, de una o más líneas,
(diagonal-asterisco-asterisco para iniciarlo, asterisco-
diagonal para terminarlo. */
Los dos primeros tipos de comentarios son los que todo programador conoce y
se utilizan del mismo modo. Los comentarios de documentación, colocados

inmediatamente antes de una declaración (de variable o función), indican que
ese comentario ha de ser colocado en la documentación que se genera
automáticamente cuando se utiliza la herramienta de Java, javadoc. Dichos
comentarios sirven como descripción del elemento declarado permitiendo
generar una documentación de nuestras clases escrita al mismo tiempo que se
genera el código.
Convenciones de nombres
SUN recomienda un estilo de codificación que es seguido en el API5
de Java y
en este material que consiste en:
• Utilizar nombres descriptivos para las clases, evitando los nombres muy
largos.
• Para los nombres de clases poner la primera letra en mayúsculas y las
demás en minúsculas. Por ejemplo: Empleado o MiClase.
• Si el nombre tiene varias palabras ponerlas todas juntas (sin separar con
- o _) y poner la primera letra de cada palabra en mayúsculas. Por
ejemplo: InstrumentoMusical.
• Para los nombres de miembros (datos y métodos) seguir la misma
norma, pero con la primera letra de la primera palabra en minúsculas.
Por ejemplo: registrarOyente.
• Para las constantes (datos con el modificador final) usar nombres en
mayúsculas, separando las palabras con _
1.6 Constantes
En Java, se utiliza la palabra clave final para indicar que una variable debe
comportarse como si fuese constante, significando con esto que no se permite
su modificación una vez que haya sido declarada e inicializada. Como es una
constante, se le ha de proporcionar un valor en el momento en que se declare,
por ejemplo:
0
8 " E& C # " " "# $ F "# $ + !" C " &: & " "# $ " " & <
"# &

class Elipse {
final float PI = 3.14159;
. . .
}
Si se intenta modificar el valor de una variable final desde el código de la
aplicación, se generará un error de compilación.
Si se usa la palabra clave final con una variable o clase estática, se pueden
crear constantes de clase, haciendo un uso altamente eficiente de la memoria,
porque no se necesitarían múltiples copias de las constantes.
La palabra clave final también se puede aplicar a métodos, significando en este
caso que los métodos no pueden ser sobrescritos.
1.7 Tipos De Datos
Los tipos de datos en Java pueden dividirse en dos categorías: simples y
compuestos. Los simples son tipos nucleares que no se derivan de otros tipos,
como los enteros, de punto flotante, booleanos y de carácter. Los tipos
compuestos se basan en los tipos simples, e incluyen las cadenas, las
matrices, etc.
Cada tipo de datos simple soporta un conjunto de literales que le pueden ser
asignados, para darles valor. En este apartado se explican los tipos de datos
simples (o primitivos) que presenta Java, así como los literales que soporta
(sintaxis de los valores que se les puede asignar).
Tipos de datos simples
Es uno de los conceptos fundamentales de cualquier lenguaje de
programación. Estos definen los métodos de almacenamiento disponibles para
representar información, junto con la manera en que dicha información ha de
ser interpretada.
Para crear una variable (de un tipo simple) en memoria debe declararse
indicando su tipo de variable y su identificador.
Sintaxis: para la declaración de variables de tipo de dato simple.
Tipo nombre [ = valor] [, nombre [ = valor]…];
Tipos de datos enteros
Se usan para representar números enteros con signo. Hay cuatro tipos: byte,
short, int y long.
Tipo Tamaño
<# 8A % #&:

' <# & 8 2 % #&:
- <# & 8*' % #&:
A <# & 82- % #&:
% ' & # & "# &
Literales enteros
Son básicos en la programación en Java y presentan tres formatos:
• Decimal: Los literales decimales aparecen como números ordinarios sin
ninguna notación especial.
• Hexadecimal: Los hexadecimales (base 16) aparecen con un 0x ó 0X
inicial, notación similar a la utilizada en C y C++.
• Octal: Los octales aparecen con un 0 inicial delante de los dígitos.
Por ejemplo, un literal entero para el número decimal 12 se representa en Java
como 12 en decimal, como 0xC en hexadecimal y como 014 en octal.
Los literales enteros se almacenan por defecto en el tipo int, (4 bytes con
signo), o si se trabaja con números muy grandes, con el tipo long, (8 bytes con
signo), añadiendo una L ó l al final del número.
La declaración de variables enteras es muy sencilla. Un ejemplo de ello sería:
long numeroLargo = 0xC; // Por defecto vale 12
Tipos de datos en punto flotante
Se usan para representar números con partes fraccionarias (o con decimales
como los conocemos normalmente). Hay dos tipos de punto flotante: float y
double. El primero reserva almacenamiento para un número de precisión
simple de 4 bytes y el segundo lo hace para un número de precisión doble de 8
bytes.
Tipo Tamaño
float 4 Bytes (32 bits)
double 8 Bytes (64 bits)
% * & # & " E & " "# $ # "#

Literales en punto flotante
Representan números decimales con partes fraccionarias. Pueden
representarse con notación estándar (563.84) o científica (5.6384e2).
De forma predeterminada son del tipo double (8 bytes). Existe la opción de usar
un tipo más corto (el tipo float de 4 bytes), especificándolo con una F ó f al final
del número.
La declaración de variables de punto flotante es muy similar a la de las
variables enteras.
Por ejemplo: declaración de variables punto flotante.
double valorDePi = 314.16e-2 ;
float temperatura = (float)36.6
Se realiza un enmascaramiento a temperatura, porque todos los literales con
decimales por defecto se consideran double.
Tipo de datos boolean
Se usa para almacenar variables que presenten dos estados, que serán
representados por los valores true y false.
Normalmente estamos acostumbrados a utilizar variables enteras como
banderas en el código, desperdiciando así mucha memoria, este desperdicio
crece conforme vamos creando banderas sobre la marcha, este vicio de
programación se arrastra debido a que la mayoría de los programadores
aprendieron a programar en lenguajes como C, en cuya estructura no existe un
tipo de dato lógico y se tenía que recurrir a los datos tipo entero. Aquí hay una
buena opción para disminuir drásticamente este desperdicio.
Literales Booleanos
Java utiliza dos palabras clave para los estados: true (para verdadero) y false
(para falso). Este tipo de literales es nuevo respecto a C/C++, lenguajes en los
que el valor de falso se representa por un 0 numérico, y verdadero cualquier
número que no fuese el 0.
Sintaxis: para declarar un dato del tipo booleano se utiliza la palabra reservada
boolean.
boolean reciboPagado = false;
Tipo de datos carácter

Se usa para almacenar caracteres Unicode simples.
Java a diferencia de C/C++ distingue entre matrices de caracteres y cadenas.
Literales carácter
Representan un único carácter (de la tabla de caracteres Unicode 1.1) y
aparecen dentro de un par de comillas simples. De forma similar que en C/C++.
Los caracteres especiales (de control y no imprimibles) se representan con una
barra invertida ('') seguida del código carácter.
Descripción Representación Valor Unicode
Caracter Unicode udddd
Numero octal ddd
Barra invertida u005C
Continuación
Retroceso b u0008
Retorno de carro r u000D
Alimentación de
formularios
f u000C
Tabulación horizontal t u0009
Línea nueva n u000A
Comillas simples ’ u0027
Comillas dobles " u0022
Números arábigos ASCII 0-9 u0030 a u0039
Alfabeto ASCII en
mayúsculas
A.-Z u0041 a u005A
Alfabeto ASCII en
minúsculas
a.-z u0061 a u007A
% - # & & & , .
Sintaxis: Las variables de tipo char se declaran de la siguiente forma
char letraMayuscula = 'A';
// Observe la necesidad de los ' '
char letraV = 'u0056'; // Letra 'V'
La clase String

+
En java las cadenas se gestionan como si fueran objetos. De ahí que String no
es un tipo de dato. Se trata de una clase, una de las ventajas de esto es que
un objeto de tipo String tiene gran variedad de métodos que se pueden usar.
En muchos lenguajes, las cadenas de texto son tipos de datos fundamentales
inherentes al lenguaje, pero en java, las cadenas son gestionadas con la clase
String.
El siguiente es un ejemplo en el que se crea una cadena y se visualiza
(observe cómo este código hace la clase String como si fuera otro tipo de dato
sencillo).
Public class MiClase{
Public static void main (String [] args){
String cadena1= “¡¡Hola Mundo!!”;
System.out.println(cadena1);
}
}
La clase String es muy ponderosa, pues con los métodos que proporciona
permite convertir la cadena en un arreglo de caracteres, convertir números en
cadenas, buscar cadenas, crear sub-cadenas, cambiar la cadena de
mayúsculas a minúsculas o viceversa, obtener la longitud de la cadena,
comparar cadenas y mucho mas.
Algunos de los métodos de la clase String son los siguientes:
int lastIndexOf (int ch)
Devuelve el índice, dentro de la
cadena, de la última ocurrencia del
carácter especificado.
int lastIndexOf (int ch, int fromIndex)
Produce el índice, dentro de la
cadena de la última ocurrencia del
carácter dado, buscando hacia atrás
desde el índice especificado.
int lastIndexOf (String str)
Devuelve el índice, dentro de la
cadena, de la ocurrencia del String
dado.
int lastIndexOf (String str, int fromIndex)
Produce el índice dentro de la
cadena de la última ocurrencia del
carácter dado.
int length() Devuelve la longitud de la cadena
String replace (char oldChar, char
newChar)
Produce una nueva cadena
substituyendo todas las ocurrencias
de oldChar con newChar
boolean startsWith (String prefix)
Chequea si la cadena empieza con
el prefijo dado.
boolean startsWith (String prefix, int
offset)
Chequea si la cadena empieza con
el prefijo dado, empezando en el
índice dado.

)
char[] to CharArray ()
Convierte una cadena en un arreglo
de caracteres.
String toLowerCase ()
Cambia todos los caracteres de la
cadena a su equivalente en
minúsculas.
String to UpperCase()
Cambia los caracteres de una
cadena a su equivalente en
mayúsculas.
String trim()
Elimina los espacios en blanco que
encuentre iniciando la búsqueda
desde ambos extremos de la
cadena.
Static String valueOf (boolean b)
Produce la representación de la
cadena del argumento booleano.
Static String valueOf (char b)
cadena del argumento char
Static String valueOf (char [] data)
cadena del arreglo de caracteres.
Static String valueOf(char[] data, offset,
int count)
cadena de un sub arreglo específico
del argumento char array de enteros.
Static String valueOf (doubleb)
Produce la representación String de
un double.
Static String valueOf (float b)
un float.
Static String valueOf (int b)
un int.
char charAt (int index)
Proporciona el carácter del índice
especificado.
int compareTo (Object o) Compara este objeto String con otro.
int compareToIgnoreCase(String
otraCadena)
Compara dos cadenas ignorando
diferencias entre mayúsculas y
minúsculas.
int compareTo (String otraCadena)
Compara que dos cadenas sean
exactamente iguales.
String concat(String str)
Concatena la cadena dada al final de
la cadena.
Boolean endsWith (String sufijo)
Verdadero si la cadena termina con
el sufijo dado.
% 0 )E# & & # "
Conversión de tipos de datos
En Java es posible transformar el tipo de una variable u objeto en otro diferente
al original con el que fue declarado. Este proceso se denomina "conversión",
“cast”, “enmascaramiento”, "moldeado" o "tipado". La conversión se lleva a
cabo colocando el tipo destino entre paréntesis, a la izquierda del valor que
queremos convertir de la forma siguiente:
char c = (char)System.in.read();

La función read devuelve un valor int, que se convierte en un char debido a la
conversión (char), y el valor resultante se almacena en la variable de tipo
carácter c.
El tamaño de los tipos que queremos convertir es muy importante. No todos los
tipos se convertirán de forma segura. Por ejemplo, al convertir un long en un
int, el compilador corta los 32 bits superiores del long (de 64 bits), de forma que
encajen en los 32 bits del int, con lo que si contienen información útil, esta se
perderá.
Por ello se establece la norma de que "en las conversiones el tipo destino
siempre debe ser igual o mayor que el tipo fuente":
Tipo Origen Tipo Destino
byte double, float, long, int, char,
short
short double, float, long, int
char double, float, long, int
int double, float, long
long double, float
float Double
% 2 ". & " & & " E & "$ !"
1.8 Variables
Las variables pueden ser de diferentes tipos y actúan como gestores de
memoria de datos. Los diferentes tipos tienen que ver con el formato de los
datos que almacenan en ellas, así como con la memoria que es necesaria para
gestionar ese dato. Por ejemplo, la variable de tipo entero (int), es de 4 bytes (o
32 bits) y se utiliza para almacenar valores enteros. Esto hace que un dato de
tipo int pueda tomar un rango de valores que van desde -2,147,483,648 hasta
2,147,483,647.
Antes de usar una variable en java, debe declararse especificando su tipo.
Sintaxis: como declarar una variable en Java.
Tipo nombre [ = valor] [, nombre [ = valor]…];
Ejemplo: declaración de una variable tipo int.

public static void main (String[] args){
int dias;
dias = 365;
System.out.println("Número de días = " +
dias);
}
}
En este código se reservan 32 bits de memoria y se etiqueta esa ubicación de
forma que el compilador entienda la variable dias, luego recibe el valor 365 y
por último, se visualiza en pantalla. Esta es la salida que se muestra en
pantalla:
Número de días = 365;
Como puede ver, hemos creado una variable para almacenar un valor y luego
visualizarlo. Una variable puede ser inicializada en el momento de declararla,
por ejemplo:
public static void main (String[] args){
int días = 365;
System.out.println("Número de días = " +
dias);
}
}
Los tipos primitivos para la declaración de variables son:
• Enteros: Estos tipos son byte, short, int y long, que guardan el signo y el
valor.
• Números en punto flotante: Estos tipos son float y double; almacenan
números flotantes con signo.
• Caracteres: char, en estas se guardan caracteres tanto alfabéticos como
numéricos.
• Booleano: en este tipo se guardan únicamente dos valores: verdadero
(true) o falso (false).
Tipo de Variable
Almacenamiento en
bytes
Rango de Valores
boolean 1 Verdadero, Falso
byte 1 -128 a 127
char 2 N/A
double 8
-1.79769313486232E308 a
-94065645841247E-324

para valores negativos y
4.94065645841247E-324 a
1.79769313486232E308
para valores positivos.
Float 4
-3.402823E38 a -
1.401298E-45 para valores
negativos y 1.401298E-45
a 3.402823E38 para
valores positivos.
int 4
-2,147,483,648 a
2,147,483,647
Long 8
-
9,223,372,036,854,775,808
a
9,223,372,036,854,775,807
Short 2 -32,768 a 32,767
% ; & . % &
La tabla 1.7 muestra los tipos de variables.
Strings
Como se mencionó anteriormente, no existe un tipo de dato String, se trata de
una clase con métodos y constructores. Entonces, la declaración de una
variable String dependerá del constructor que se desea utilizar. La manera más
sencilla es String nombre; y posteriormente asignas cualquier valor que
queramos. Sin embargo si usted tiene la necesidad de crearlas de una manera
distinta, aquí se muestran algunos de sus constructores.
Constructor Descripción
String ()
Inicializa un nuevo objeto String para
gestionar una secuencia de caracteres
vecía.
String (byte[] bytes)
Construye un nuevo objeto String
convirtiendo el arreglo de bytes
mediante la codificación de caracteres
que tiene la plataforma por defecto.
String (byte[] bytes, int offset, int
length)
convirtiendo el subarreglo de bytes
usando la codificación de caracteres
por defecto.
String (byte[] bytes bytes, int offset,
enc)
Construye un Nuevo objeto String
convirtiendo el entero length y el
subarreglo de caracteres utilizando la
codificación de caracteres
especificada.
String (byte[] bytes, String enc)
convirtiendo el arreglo de bytes
mediante la codificación de caracteres

que se especifica.
String (char[] value)
Aloca un nuevo objeto String para
representar la secuencia de
caracteres.
% A "&# # & & # "
La tabla 1.8 muestra la lista de constructores.
Ejemplos: Distintas formas de crear e inicializar cadenas.
&# $ < 5 & . &#
public static void main (String [] args){
String s1 = “Hola Mundo!”;
.
.
.
}
}
& " " < " + & &# "#
String s2;
s2 = “Hola!”;
.
.
}
}
& " " . @ < & " & # &
String s2;
s2 = “Hola!”;
string s3 = new String();
s3 = “Hola de nuevo!”;
.
}
}
7# + & " & "&# # & & # "

String s2;
s2 = “Hola!”;
string s3 = new String();
s3 = “Hola de nuevo!”;
String s4 = new String(“Usamos
Constructor!”);
.
.
.
}
}
) !
Los operadores son un tipo de tokens que indican una evaluación o
computación para ser realizada en objetos o datos, y en definitiva sobre
identificadores o constantes. Además de realizar la operación, un operador
devuelve un valor, ya que son parte fundamental de las expresiones.
El valor y tipo que devuelve depende del operador y del tipo de sus operandos.
Por ejemplo, los operadores aritméticos devuelven un número como resultado
de su operación. Los operadores realizan alguna función sobre uno, dos o tres
operandos.
Los operadores que requieren un operando son llamados operadores unarios.
Por ejemplo, el operador "++" es un operador unario que incrementa el valor de
su operando en una unidad.
Los operadores unarios en Java pueden utilizar tanto la notación prefija como
la posfija.
La notación prefija indica que el operador aparece antes que su operando.
++contador; // Notación prefija, se evalúa a: contador+1
La notación posfija indica que el operador aparece después de su operando:
contador++ // Notación posfija, se evalúa a: contador
Los operadores que requieren dos operandos se llaman operadores binarios.
Por ejemplo el operador "=" es un operador binario que asigna el valor del
operando del lado derecho al operando del lado izquierdo.

Todos los operadores binarios en Java utilizan notación infija, lo cual indica que
el operador aparece entre sus operandos.
operando1 <operador> operando2
Por último, los operadores ternarios son aquellos que requieren tres operandos.
El lenguaje Java tiene el operador ternario, "?", que es una sentencia similar a
la if-else.
Este operador ternario usa notación infija; y cada parte del operador aparece
entre operandos:
expresión ? operación1 : operación2
Los operadores de Java se pueden dividir en las siguientes cuatro categorías:
• Aritméticos.
• De comparación y condicionales.
• A nivel de bits y lógicos.
• De asignación.
Operadores aritméticos
El lenguaje Java soporta varios operadores aritméticos para los números
enteros y en punto flotante. Se incluye + (suma), - (resta), * (multiplicación), /
(división), y % (módulo, es decir, resto de una división entera). La tabla 1.9
muestra los operadores aritméticos.
Por ejemplo:
sumaEste + aEste; //Suma los dos enteros
divideEste % entreEste; //Calcula el resto de dividir 2
enteros
Operador Uso Descripción
+ op1 + op2 Suma op1 y op2
- op1 - op2 Resta op2 de op1
* op1 * op2 Multiplica op1 por op2
/ op1 / op2 Divide op1 entre op2
% op1 % op2
Calcula el resto de dividir op1 entre
op2
% B & # E# & % " & , .

El tipo de los datos devueltos por una operación aritmética depende del tipo de
sus operandos; si se suman dos enteros, se obtiene un entero. Estos
operadores se deben utilizar con operandos del mismo tipo, o si no realizar una
conversión de tipos de uno de los dos operandos al tipo del otro.
El lenguaje Java sobrecarga la definición del operador “+” para incluir la
concatenación de cadenas. El siguiente ejemplo utiliza “+” para concatenar la
cadena "Contados ", con el valor de la variable contador y la cadena "
caracteres.":
System.out.print("Contados" + contador + "caracteres.");
Esta operación automáticamente convierte el valor entero de contador a una
cadena de caracteres.
Los operadores + y - tienen versiones unarias que realizan las siguientes
operaciones:
+ +op
Convierte op a entero si es un byte, short o
char
- -op Niega aritméticamente op
% = & " & " & & & GHG < GFG
El operador - realiza una negación del número en complemento a 2, es decir,
cambiando de valor todos sus bits y sumando 1 al resultado final:
42 -> 00101010
-42 -> 11010110
Existen dos operadores aritméticos que funcionan como atajo de la
combinación de otros: ++ que incrementa su operando en 1, y -- que
decrementa su operando en 1. Ambos operadores tienen una versión prefija, y
otra posfija. La utilización correcta es crítica en situaciones donde el valor de la
sentencia es utilizado en mitad de un cálculo más complejo, por ejemplo para
control de flujos.
++ op++
Incrementa op en 1; se evalúa con valor anterior al
incremento
++ ++op
Incrementa op en 1; se evalúa con valor posterior al
incremento
-- op--
Decrementa op en 1; se evalúa con valor anterior al
incremento
-- --op Decrementa op en 1; se evalúa con valor posterior al

incremento
% " & " GHHG < GFFG
Operadores de comparación y condicionales
Un operador de comparación compara dos valores y determina la relación
existente entre ambos. Por ejemplo, el operador “!=” devuelve verdadero (true)
si los dos operandos son distintos. La siguiente tabla resume los operadores de
comparación de Java:
Operador Uso Devuelve verdadero si
> op1 > op2 op1 es mayor que op2
>= op1 >= op2 op1 es mayor o igual que op2
< op1 < op2 op1 es menor que op2
<= op1 <= op2 op1 es menor o igual que op2
== op1 == op2 op1 y op2 son iguales
!= op1 != op2 op1 y op2 son distintos
% & !"
Los operadores de comparación suelen ser usados con los operadores
condicionales para construir expresiones complejas que sirvan para la toma de
decisiones. Un operador de este tipo es “&&”, el cual realiza la operación
booleana and. Por ejemplo, se pueden utilizar dos operaciones diferentes de
comparación con “&&” para determinar si ambas relaciones son ciertas. La
siguiente línea de código utiliza esta técnica para determinar si la variable index
de una matriz se encuentra entre dos límites (mayor que cero y menor que la
constante NUMERO_ENTRADAS):
( 0 < index ) && ( index < NUMERO_ENTRADAS )
Se debe tener en cuenta que en algunos casos, el segundo operando de un
operador condicional puede no ser evaluado. En caso de que el primer
operando del operador && sea falso, Java no evaluará el operando de la
derecha:
(contador < NUMERO_ENTRADAS) && ( in.read() != -1 )
Si contador es mayor o igual que NUMERO_ENTRADAS, el valor de retorno de
&& puede ser determinado sin evaluar el operando de la parte derecha. En este
caso in.read no será llamado y un carácter de la entrada estándar no será
leído.
Si el programador quiere que se evalúe la parte derecha, deberá utilizar el
operador & en lugar de &&.
De la misma manera se relacionan los operadores || y | para la exclusión lógica
(OR).

+
Java soporta cinco operadores condicionales, mostrados en la siguiente tabla:
Operador Uso Devuelve verdadero si...
&& op1 && op2
op1 y op2 son ambos verdaderos, condicionalmente
evalúa op2
& op1 & op2
op1 y op2 son ambos verdaderos, siempre evalúa op1
y op2
|| op1 || op2
op1 o op2 son verdaderos, condicionalmente evalúa
op2
| op1 | op2 op1 o op2 son verdaderos, siempre evalúa op1 y op2
! ! op op es falso
% ' & " " &
Además Java soporta un operador ternario, el “?:”, que se comporta como una
versión reducida de la sentencia if-else:
expresion ? <operacion1> : operacion2
El operador ?: evalúa la expresion y devuelve operación1 si es cierta, o
devuelve operación2 si expresion es falsa.
Operadores de bit
Un operador de bit permite realizar operaciones de bit sobre los datos. Existen
dos tipos: los que desplazan (mueven) bits, y operadores lógicos de bit.
Operadores de desplazamiento de bits
Operador Uso Operación
>> op1 >> op2 Desplaza los bits de op1 a la derecha op2 veces
<< op1 << op2 Desplaza los bits de op1 a la izquierda op2 veces
>>> op1 >>> op2
Desplaza los bits de op1 a la derecha op2 veces
(sin signo)
% * & & + "# % #&
Los tres operadores de desplazamiento simplemente desplazan los bits del
operando de la parte izquierda el número de veces indicado por el operando de
la parte derecha. El desplazamiento ocurre en la dirección indicada por el
operador. Por ejemplo, la siguiente sentencia, desplaza los bits del entero 13 a
la derecha una posición:
13 >> 1;
La representación en binario del número 13 es 1101. El resultado de la
operación de desplazamiento una posición a la derecha es 110 o 6 en decimal.
Se debe tener en cuenta que el bit más a la derecha se pierde en este caso.

)
Un desplazamiento a la derecha una posición es equivalente a dividir el
operando del lado izquierdo por 2, mientras que un desplazamiento a la
izquierda de una posición equivale a multiplicar por 2, pero un desplazamiento
es más eficiente computacionalmente hablando, que una división o
multiplicación.
El desplazamiento sin signo >>> funciona de la siguiente manera:
• Si se desplaza con signo el número -1 (1111), seguirá valiendo -1, dado
que la extensión de signo sigue introduciendo unos en los bits más
significativos.
• Con el desplazamiento sin signo se consigue introducir ceros por la
izquierda, obteniendo el número 7 (0111).
Operadores de lógica a nivel de bits
La lógica de bits (lógica de Bool) se utiliza para modelar condiciones biestado y
trabajar con ellas (cierto/falso, true/false, 1/0). En Java hay cuatro operadores
de lógica de bits:
Operador Uso Operación
& op1 & op2 AND
| op1 | op2 OR
^ op1 ^ op2 OR Exclusivo
~ ~op2 Complemento
% - & ! " . % #&
El operador & realiza la operación AND de bit. Aplica la función AND sobre
cada par de bits de igual peso de cada operando. La función AND es evaluada
a cierto si ambos operandos son ciertos. Por ejemplo vamos a aplicar la
operación AND a los valores 12 y 13:
12 & 13
El resultado de esta operación es 12. ¿Por qué?. La representación en binario
de 12 es 1100, y de 13 es 1101. La función AND pone el bit de resultado a uno
si los dos bits de los operandos son 1, sino, el bit de resultado es 0:
1100
& 1101
-----------
1100

El operador | realiza la operación OR de bit. Aplica la función OR sobre cada
par de bits de igual peso de cada operando. La función OR es evaluada a cierto
si alguno de los operandos es cierto. Entonces 12 | 13 genera el resultado 13.
El operador ^ realiza la operación OR exclusivo de bit (XOR). Aplica la función
XOR sobre cada par de bits de igual peso de cada operando. La función XOR
es evaluada a cierto si alguno de los operandos es cierto, pero no los dos.
Entonces 12 ^ 13 genera el resultado 1.
Para finalizar, el operador de complemento invierte el valor de cada bit del
operando. Convierte el falso en cierto, y el cierto en falso. Entre otras cosas, la
manipulación bit es útil para gestionar indicadores booleanos (banderas).
Supongamos, por ejemplo, que se tienen varios indicadores booleanos en
nuestro programa, los cuales muestran el estado de varios componentes del
programa: esVisible, esArrastrable, etc... En lugar de definir una variable
booleana para cada indicador, se puede definir una única variable para todos
ellos. Cada bit de dicha variable representará el estado vigente de uno de los
indicadores. Se deberán utilizar entonces manipulaciones de bit para
establecer y leer cada indicador.
Primero, se deben preparar las constantes de cada indicador. Esos indicadores
deben ser diferentes unos de otros (en sus bits) para asegurar que el bit de
activación no se solape con otro indicador. Después se debe definir la variable
de banderas, cuyos bits deben de poder ser configurados según el estado
vigente en cada indicador.
El siguiente ejemplo inicia la variable de banderas flags a 0, lo que significa que
todos los indicadores están desactivados (ninguno de los bits es 1):
final int VISIBLE = 1;
final int ARRASTRABLE = 2;
final int SELECCIONABLE = 4;
final int MODIFICABLE = 8;
int flags = 0;
Para activar el indicador VISIBLE, se deberá usar la sentencia:
flags = flags | VISIBLE;
Para comprobar la visibilidad se deberá usar la sentencia:
if ( (flags & VISIBLE) == 1 )
Operadores de asignación

El operador de asignación básico es el =, que se utiliza para asignar un valor a
otro. Por ejemplo:
int contador = 0; //Inicia la variable contador con 0.
Java además proporciona varios operadores de asignación que permiten
realizar un atajo en la escritura de código. Permiten realizar operaciones
aritméticas, lógicas, de bit y de asignación con un único operador.
Supongamos que necesitamos sumar un número a una variable y almacenar el
resultado en la misma variable, como a continuación:
i = i + 2;
Se puede abreviar esta sentencia con el operador de atajo +=, de la siguiente
manera:
i += 2;
La siguiente tabla muestra algunos de los operadores de atajo de asignación y
sus equivalentes largos:
Operador Uso Equivalente a
+= 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
&= op1 &= op2 op1 = op1 & op2
% 0 & # & " !"
Precedencia de operadores
Cuando en una sentencia aparecen varios operadores el compilador deberá de
elegir en qué orden aplica los operadores. A esto se le llama precedencia.
Los operadores con mayor precedencia son evaluados antes que los
operadores con una precedencia menor.
Cuando en una sentencia aparecen operadores con la misma precedencia:
• Los operadores de asignación son evaluados de derecha a izquierda.
• Los operadores binarios, (menos los de asignación) son evaluados de
izquierda a derecha.

Se puede indicar explícitamente al compilador de Java cómo se desea que se
evalúe la expresión con paréntesis balanceados ( ). Para hacer que el código
sea más fácil de leer y mantener, es preferible ser explícito e indicar con
paréntesis que operadores deben ser evaluados primero.
La siguiente tabla muestra la precedencia asignada a los operadores de Java.
Los operadores de la tabla están listados en orden de precedencia: cuanto más
arriba aparezca un operador, mayor es su precedencia. Los operadores en la
misma línea tienen la misma precedencia:
Tipo de operadores Operadores de este tipo
Operadores posfijos [ ] . (parametros) expr++ expr--
Operadores unarios ++expr --expr +expr -expr ~ !
Creación o conversión new (tipo) expr
Multiplicación * / %
Suma + -
Desplazamiento << >> >>>
Comparación < > <= >= instanceof
Igualdad == !=
AND a nivel de bit &
OR a nivel de bit ^
XOR a nivel de bit |
AND lógico &&
OR lógico ||
Condicional ? :
Asignación = += -= *= /= %= &= ^= |= <<= >>= >>>=
% 2 " &
Por ejemplo, la siguiente expresión produce un resultado diferente
dependiendo de si se realiza la suma o división en primer lugar:
x + y / 100
Si no se indica explícitamente al compilador el orden en que se quiere que se
realicen las operaciones, entonces el compilador decide basándose en la
precedencia asignada a los operadores. Como el operador de división tiene
mayor precedencia que el operador de suma el compilador evaluará y/100
primero. Así:
x + y / 100
Es equivalente a:
x + (y / 100)

1.10 Sentencias
La unidad básica de ejecución es una sentencia, Java determina el fin de una
sentencia mediante el “;”. Un bloque es un conjunto de sentencias
comprendidas entre dos llaves ({ }). Es importante remarcar que los bloques
definen el alcance de las variables y que los bloques pueden anidarse.
Como la mayoría de los lenguajes de programación Java tiene sentencias
condicionales y de ciclo (ciclo). A continuación se presentan breves ejemplos,
cada sentencia se explica con gran detalle en el punto 1.13 Estructuras de
control.
Condicionales
if(<condición>){
<sentencia>*
}
if(<condición>){
<sentencia>*
}else{
<sentencia>*
}
switch(<variable>){
case<valor>:
<sentencia>*
break;
case<valor>:
<sentencia>*
break;
default:
<sentencia>*
break;
}
Ciclos o Ciclos
for(<valor_inicial>;<condición>;<incremento>){
<sentencia>*
}
while(<condición>){
<sentencia>*
}
do{
<sentencia>*
} while(<condición>);
% ; "# " & " " & <
Como los bloques se pueden anidar no hay problemas por definir una
sentencia de control dentro de otra:

Las condiciones deben ser sentencias que forzosamente devuelven un
booleano (un valor cierto o falso), por lo tanto una asignación i=34 no es una
condición válida, ni el 0 es equivalente a false o el 1 a true.
break: La palabra reservada break puede utilizarse para romper la secuencia
de ejecución dentro de los ciclos.
continue: La palabra reservada continue funciona de forma similar a break con
la diferencia que no rompe el ciclo, sino que simplemente se salta una
iteración.
1.11 Matrices
Se define como un conjunto de datos del mismo tipo organizados en dos o más
columnas y uno o más renglones, es decir es un arreglo bidimensional o una
tabla. Los arreglos con dos dimensiones se utilizan a menudo para representar
tablas de valores, que constan de información ordenada en filas y columnas.
Para identificar un elemento especifico de una tabla, se deben especificar los
índices. Por convención, el primer índice indica la fila del elemento y el
segundo, su columna. En Java los arreglos bidimensionales son arreglos de
arreglos. Como era de esperarse, se parecen y actúan como los arreglos
multidimensionales.
Las matrices se derivan de los arreglos (arrays), de hecho son arreglos
multidimensionales, debido a ello daré una breve explicación sobre ellos.
Inicialización de arreglos
Para inicializar los arreglos unidimensionales, únicamente hay que poner los
valores entre llaves, un valor detrás de otro, separados por comas, empezando
con el primer valor del arreglo.
Ejemplo: Declaración e inicialización de un arreglo.
double cuentas[] = {345.6, 999.0, 0, 1000.5};
cuantas[3] = 1000.5;
System.out.println("La cuenta 3 debe $" +
cuentas[3]);
}
}
Declaración de matrices
Se pueden declarar matrices de una manera muy similar a como se declaran
los arreglos, solo se incluyen un par de corchetes adicionales. Serian arreglos
multidimensionales. De hecho, se agrega un par de corchetes adicionales por

cada dimensión, por ejemplo, para un arreglo, que es de una dimensión, se
incluye un par de corchetes, para uno bidimensional, se incluirán dos pares.
Tipo nombre [][]….;
Sintaxis: Declaración y creación de una matriz de dos filas y 100 columnas
tipo nombreMatriz [][] = new tipo [filas][columnas];
tipo [][] nombreMatriz = new tipo [filas][columnas];
Ejemplo:
double accounts [][] = new double [2][100];
Podría incluso declarar arreglos de mas dimensiones.
Ejemplo: Declaración de un arreglo de cuatro dimensiones.
double cuentas [][][][] = new double [2] [3] [4] [5];
Usted podría declarar únicamente una matriz y crearla posteriormente.
Ejemplo:
double cuentas[][]; //declaración de la matriz
//demás sentencias
cuentas = new double[2][4];//creación de la matriz
cuentas[0][0] = 1000.5;
System.out.println("Valor en cuentas [0][0]"+
cuentas[0][0]);
}
}
Inicialización de matrices
Las matrices se pueden inicializar cuando se les declara, de la misma forma
que inicializaron lo arreglos; basta con poner un par de corchetes para cada
dimensión y poner los valores con los que se quiere inicializar el arreglo dentro
de los mismos.
Ejemplo:

double cuentas[][] = {{10.1, 14.4, 5067.88,
7.7}, {345.67, 67.8, 678.890, 43.0}};
System.out.println("Valor en cuentas [0][3]"+
cuentas[0][3]);
}
}
Creación de matrices
Como en otros lenguajes de programación, en Java, las matrices, son arreglos
de arreglos. Esto quiere decir que se pueden construir arreglos como se quiera;
como en el ejemplo siguiente, en el que cada fila de un arreglo de dos
dimensiones tiene un diferente número de elementos.
Ejemplo:
double matriz[][] = new double [5][];
matriz[0] = new double [500];
matriz[0][3] = 4567.886;
System.out.println("En matriz [0][3] "+
cuentas[0][3]);
}
}
Mostrar una matriz
Mostrar una matriz en la pantalla de texto es difícil, ya que Java no dispone de
una función que sitúe el cursor de texto en una posición de la pantalla, como lo
hace la función gotoxy disponible en los lenguajes C/C++. La única alternativa
que queda es mostrar los elementos de una fila unos a continuación de los
otros separados por un tabulador, después otra fila y así hasta mostrar todos
los elementos de la matriz.
En el siguiente ejemplo se muestra en pantalla una matriz de 2 x 3; primero se
inicializa la matriz en la línea int [][]a ={{1,2,3},{10,20,30}};. Se separan los
elementos de una fila mediante el carácter tabulador 't', Cuando se acaba una
fila se inserta un retorno de carro 'n' y se continua con la siguiente fila, y así
sucesivamente.

int[][] matriz = {{1,2,3},{10,20,30}};
for (int fila=0; fila<2; fila++){
for(int columna=0; columna<3; columna++){
System.out.println(
matriz[fila][columna] +"t");
}
System.out.println("n");
}
}
}
Como inicializamos la matriz con dos grupos de números, estos representarán
dos columnas, y como cada grupo de números contiene tres números, cada
uno de ellos es una fila, recomiendo que si es confuso identificar el número de
filas y de columnas al inicializar una matriz al momento de su declaración,
créela de alguna de las otras maneras explicada anteriormente.
La salida es:
1 2 3
10 20 30
1.12 Procedimientos y funciones
Funciones
Supongamos que queremos depositar todo nuestro dinero ganado como
programadores. Hay dos bancos en los que podemos llevar a cabo un depósito
y ganar algunos intereses. El primero, lo llamamos "Banco A", nos ofrecen un
interés con una tasa mensual del 1 % mas una bonificación final del 5%. El
segundo, el "Banco B", nos ofrece una tasa del 1.5 %.
Realizamos un algoritmo para obtener el mayor beneficio. El programa
calculará el monto obtenido en un período de 12 meses con un cálculo de
interés compuesto. Para darnos una mejor idea de lo que tenemos que hacer
elaboramos el algoritmo principal.
double monto = 10000;
double meses = 12;
for ( int n = 1; n <= meses; n++){
monto = monto + monto * interés / 100;
}
Al monto inicial le sumamos las sucesivas capitalizaciones que ganamos mes a
mes, hasta llegar a un período de 12 meses.

+
Con este algoritmo probado, codificamos el programa:
public class ShowMeTheMoney{
public static void main(String args[]){
int meses = 12;
float interesBanco1 = 1f;
float bonificBanco1 = 5f;
float interesBanco2 = 1.5f;
double montoBanco1 = monto;
montoBanco1+=montoBanco1 * interesBanco1 / 100;
}
montoBanco1 += montoBanco1 * bonificBanco1 /100;
montoBanco2+=montoBanco2 * interesBanco2 / 100;
}
System.out.println("Importe final del banco1 : " +
montoBanco1);
montoBanco2);
}
}
Esto ocurrirá cada vez que tengamos que realizar un cálculo de intereses. Si la
elección se extendiera a, por ejemplo, cinco bancos, tendríamos que copiar el
algoritmo para cada uno de ellos. Para no tener que repetir una y otra vez lo
mismo, podemos recurrir a una técnica muy utilizada en programación: dividir el
código en funciones.
Una función es un conjunto de instrucciones que ejecutan una rutina y
devuelven un resultado. El resultado puede depender de parámetros de
entrada. Una función se construye de la siguiente manera:
tipo_resultado nombre_función (tipo_parámetro
nombre_parámetro, ... ) {
sentencia1;
sentencia2;
...
sentenciaN;
return unValor;
}
Se debe definir el tipo de dato del resultado y el nombre que identifica a la
función. Además, opcionalmente se pueden definir parámetros de entrada con
el tipo de dato y su nombre.
Una función permite que reutilicemos un algoritmo. En el caso de nuestro
problema bancario, podemos reutilizar el cálculo de interés aplicándolo a cada
banco. Veamos cómo se construye esta función:

)
double interesCompuesto(double monto, float tasa, int
períodos){
for(int n = 1; n <= períodos; n++ ){
monto += monto * tasa / 100;
}
return monto;
}
Necesitamos definir ciertos datos de entrada para ejecutar el algoritmo. Vamos
a necesitar el monto inicial, la tasa de interés y el período. A su vez definimos
el tipo de datos del resultado. La función nos devuelve el monto final, entonces
el tipo de dato es double. Para identificar a la función le hemos puesto el
nombre de interesCompuesto.
Para utilizar la función en el programa la llamamos por su nombre. Como la
función devuelve un resultado, tendremos que almacenarlo en una variable que
tenga un tipo de dato compatible con el resultado.
double montoBanco2 = interesCompuesto(10000 , interesBanco2, meses);
Debemos pasar los parámetros como se han definido, en el mismo orden y con
el mismo tipo de dato.
Conociendo como se arma y se invoca una función, estamos listos para
utilizarla en nuestro programa.
public class ShowMeTheMoney2{
static double interesCompuesto(double monto, float tasa,
int períodos){
for(int n = 1; n <= períodos; n++ ){
monto += monto * tasa / 100;
}
return monto;
}
public static void main(String args[]){
int meses = 12;
float interesBanco1 = 1f;
float bonificBanco1 = 5f;
float interesBanco2 = 1.5f;
montoBanco1 = interesCompuesto( montoBanco1,
interesBanco1, meses );
montoBanco1 += montoBanco1 * bonificBanco1 /100;
montoBanco2 = interesCompuesto( montoBanco2,
interesBanco2, meses );
montoBanco1);

montoBanco2);
}
}
Ejercicio 1.5: Cree una función que muestre un menú que le permita decidir qué
operación realizar. Esto de acuerdo al proyecto que se ha venido
desarrollando. De acuerdo a cada opción, el usuario deberá ingresar un
número o una letra que identifique cada opción.
Procedimientos
Los procedimientos son también funciones programadas por el usuario. Son
muy parecidos a los métodos, de hecho muchas personas que publican
tutoriales o guías en la red, se refieren a los procedimientos como métodos.
Los procedimientos son invocados escribiendo el nombre del objeto, seguido
del operador punto (.), y después el nombre del procedimiento que ofrece la
clase y que describe sus atributos y comportamientos. Como cualquier rutina
los métodos pueden incorporar argumentos.
Declaración de procedimientos
Sintaxis.
<modificador>*<tipo_regresado><nombre>(<argumentos>*){
<cuerpo>*
}
• Los modificadores pueden ser: public, protected , prívate.
• El modificador de acceso público indica que el procedimiento puede ser
llamado desde otro código.
• Un procedimiento privado indica que solo puede ser llamado por otros
métodos dentro de la clase.
• Se pueden sobrecargar los procedimientos. (Procedimientos con el
mismo nombre pero que funcionan diferente de acuerdo a los
parámetros que reciben.)
Ejemplo: crear el procedimiento setPeso, esta función nos servirá para
asignar un valor a este atributo del objeto y otro procedimiento que nos
regrese dicho valor. (getPeso)

public class Perro{
private int peso;
public int getPeso(){
return peso;
}
public void setPeso(int nuevoPeso){
if(nuevoPeso > 0){
peso = nuevoPeso;
}
}
}
Para sobrecargar un procedimiento utilizaremos lo que se conoce como
polimorfismo. Esta función ya fue analizada y ejemplificada en la parte 1.1.1
Objetos, de cualquier forma he aquí una breve explicación.
Para sobrecargar un procedimiento, sólo hay que definirlo más de una vez,
especificando una nueva lista de parámetros en cada una de ellas. Cada lista
de parámetros debe ser diferente de cualquier otra de alguna forma, el número
de parámetros o el tipo de uno o más de ellos.
Ejemplo: Sobrecargaremos el método setPeso del ejemplo anterior.
public class Perro{
private int peso;
public int getPeso(){
return peso;
}
public void setPeso(int nuevoPeso){
if(nuevoPeso > 0){
peso = nuevoPeso;
}
}
public void setPeso(int nuevoPeso, int viejoPeso){
if(nuevoPeso > 0 && viejoPeso<100){
peso = nuevoPeso;
}
}
}
La referencia this
En ocasiones es conveniente disponer de una referencia que apunte al propio
objeto que se está manipulando. Esto se consigue con la palabra reservada
this. this es una referencia implícita que tienen todos los objetos y que apunta a
sí mismo. Por ejemplo:

//Se ejemplifica el uso de this
public class Perro{
private int peso;
public void setPeso(int peso){
this.peso = peso;
}
public Perro elPesoMayor(Perro nuevo){
if( peso > nuevo.peso) return this;
else return nuevo;
}
}
/*En este ejemplo se compara el valor de la
variable peso de dos objetos, lo que se regresa
es el objeto cuyo valor en peso sea mayor.*/
El método elPesoMayor devuelve una referencia al perro que tiene mayor peso,
comparando los pesos del Perro nuevo que se recibe como argumento y el
propio. En caso de que el propio resulte mayor el método debe devolver una
referencia a sí mismo. Esto se consigue con la expresión return this.
Al ir avanzando conocerá métodos en los cuales se debe enviar o recibir como
parámetro un objeto, en todos esos casos será de mucha utilidad la referencia
this.
Ejercicio 1.6: Realice los cambios necesarios (diseñar clase, procedimientos o
funciones) para agregar funcionalidad a nuestra aplicación. Agregue por lo
menos 3 habilidades nuevas a nuestra calculadora. Por ejemplo: sacar la raíz
cuadrada, elevar un número a una potencia, etc. Obviamente estas nuevas
opciones deberán aparecer en nuestro menú por lo que deberá modificar
algunas de sus funciones.
1.13 Estructuras de control
Durante un programa existen acciones que se han de repetir un número
determinado de veces. Por ejemplo, leer 3 caracteres de un flujo de entrada in
se codificaría:
in.read();
in.read();
in.read();
Este código además de poco elegante sería inviable para una repetición de
3000 lecturas. Por eso aparecen las estructuras de control, que facilitan que
determinadas acciones se realicen varias veces, mientras que una condición se

INSTITUTO_TECNOLOGICO_DE_MORELIA_PROGRAM.pdf

INSTITUTO_TECNOLOGICO_DE_MORELIA_PROGRAM.pdf

Recomendados

Recomendados

Más contenido relacionado

Similar a INSTITUTO_TECNOLOGICO_DE_MORELIA_PROGRAM.pdf

Similar a INSTITUTO_TECNOLOGICO_DE_MORELIA_PROGRAM.pdf (20)

Más de AnaLpez275

Más de AnaLpez275 (18)

Último

Último (11)

INSTITUTO_TECNOLOGICO_DE_MORELIA_PROGRAM.pdf