UNIDAD I
INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETO Y DESARROLLO DEL SOFTWARE E
INICIO EN JAVA INCLUYENDO DATOS NUMÉRICOS
JAVA INTRODUCCIÓN
Módulo I
Introducción a la programación orientada a
objeto y desarrollo del software e inicio en
Java incluyendo datos numéricos
Contenido
Introducción: ................................................................................................................. 3
Desarrollo ..................................................................................................................... 4
1.
Programa Orientado a Objeto (POO) .............................................................. 4
Dentro de JAVA, la POO resalta algunos conceptos fundamentales para
su utilización: ........................................................................................................ 6
2.
Clases e instancias de valores de datos ......................................................... 7
3.
Ingeniería de software y ciclo de vida del software ......................................... 8
Hay cinco fases principales en el ciclo de vida de un software: ............... 9
4.
Componentes del programa ......................................................................... 10
Comentarios .......................................................................................... 10
Sentencia import (de importación) ......................................................... 11
Declaración de clase ............................................................................. 12
5.
Ciclo editar – Compilar - Ejecutar ................................................................. 13
Algunas clases estándar en Java ............................................................................... 17
Ejemplo de desarrollo ................................................................................................. 20
Pasos del desarrollo ................................................................................................... 21
Variables..................................................................................................................... 25
Expresiones aritméticas .............................................................................................. 27
Constantes ................................................................................................................. 28
La clase Math ............................................................................................................. 30
Generación de números aleatorios ............................................................................. 31
La clase gregoriancalendar ......................................................................................... 32
Representación numérica ........................................................................................... 34
Bibliografía .................................................................................................................. 36
Optativa I – Java Introducción
Prof. Adan Morel
2
Introducción a la programación orientada a
objeto y desarrollo del software e inicio en
Java incluyendo datos numéricos
Aspectos Motivacionales:
Fuente: www.desmotivaciones.es
Introducción:
Como describe la imagen anterior, la programación es un estilo de vida, estamos
ligados a ella de manera constante. En nuestra existencia diaria, muchas veces
sin darnos cuenta, realizamos rutinas como levantarnos, desayunar, ir al trabajo,
etc. Siempre siguiendo la misma secuencia. Ahora, imaginémonos que todo lo
Optativa I – Java Introducción
Prof. Adan Morel
3
que realizamos pueda quedar plasmado en un programa, donde cada actividad
que realicemos sea independiente pero igual de importante que el resto.
Con esta idea fue que a mediados de los ’90 nace JAVA como lenguaje orientado
a objetos, multiplataforma y de fácil utilización. Prácticamente, la mayoría de las
empresas utilizan algún módulo o plataforma desarrollada en este lenguaje por
su independencia para ser ejecutados en cualquier plataforma, sin mencionar las
retribuciones económicas ofrecidas a los desarrolladores.
Estas características convierten a JAVA en una pieza indispensable en la hoja
de vida (curriculum vitae) de todo programador.
En las siguientes páginas, tendremos una vista detallada de este potente
lenguaje que hoy en día es la más utilizada, presente desde los aspectos más
simples a los más complejos de nuestra vida.
Desarrollo
1. Programa Orientado a Objeto (POO)
Antes de comenzar a programar, debemos de conocer algunos detalles que
hacen este conglomerado práctico expresado en lenguaje.
Actualmente, en el mercado, existen innumerables programas que utilizan el
paradigma de POO pero JAVA es considerado la punta de la pirámide del
mercado por sus características mencionadas anteriormente.
La Programación Orientada a Objeto nace como la idea de representar un
sistema en bloques independientes que interactúan entre si teniendo un
resultado común. Expresando lo anterior de manera sencilla, es utilizar la célebre
frase “divide y vencerás” para programar. La representación de este paradigma
es encapsular los datos y métodos en un objeto, así tenemos diferentes objetos
Optativa I – Java Introducción
Prof. Adan Morel
4
con cierta autonomía, cada uno con métodos y datos internos (privados) y bien
diferenciados del entorno en el que se encuentran.
Utilicemos nuestra imaginación. Quien no
ha
sido
reprochado
por
su
madre
(generalmente) por algún desorden en
nuestros cuartos. Nosotros pertenecemos a
un gran sistema llamado CASA, cada uno
de nosotros dependemos de nuestros
Imagen proveída por el docente
PADRES
durante
la
adolescencia
y
tenemos un lugar asignado dentro de la CASA denominado CUARTO.
Dentro
del
CUARTO
tenemos
distintos
OBJETOS que utilizamos para nuestra vida
diaria (vestimentas, camas, calzados, etc.).
Cuando estos no se encuentran en el lugar
correspondiente se genera un caos en el
momento
que
necesitamos
utilizar
algún
Imagen proveída por el docente
recurso. Si bien sabemos que, por ejemplo,un
zapato que necesitamos está en el CUARTO, pero no podemos ubicarlo debido
al desorden.
Es así que, al ver el desorden, los PADRES comienzan a actuar arreglando el
CUARTO y disponiendo cada OBJETO en su lugar teniendo como resultado un
ambiente ordenado. Es así como funciona la POO, disponiendo de cada
OBJETO en un lugar de fácil acceso y manejo para el usuario común.
Volviendo al tecnicismo de la POO, cada objeto debe de interactuar con los
elementos del sistema utilizando una interfaz definida a través de métodos
públicos, pudiendo ser estos invocados desde afuera. Esto nos ayuda a
gestionar sistemas de gran complejidad y desglosarlos en pequeñas unidades
funcionales.
Optativa I – Java Introducción
Prof. Adan Morel
5
Dentro de JAVA, la POO resalta algunos conceptos
fundamentales para su utilización:
1.1.1. Clases y objetos
► Clases: Elemento fundamental en la POO. Cuenta con una serie de
métodos y propiedades que definen el comportamiento y la forma que
posee un objeto. Define las especificaciones formales que identificaran
unas clases de otras. Existen varios tipos de clases, las públicas (public)
que son accesibles desde otras clases, referenciadas en forma directa o
por herencia fuera del paquete donde fueron declaradas.
Así mismo, tenemos las clases abstractas (abstract) que, sin falta, poseen
al menos un método abstracto (está definido el método pero no está
implementado). Se define la arquitectura pero no la acción, por decirlo de
una forma. Este tipo de clases no son instanciadas.
► Objeto: Es la instanciación de una Clase. Se debe definir una clase antes
de crear una instancia (objeto) de la clase. Un programa escrito en un
estilo orientado a objetos consistirá en objetos que interactúan entre sí.
Un objeto consta de datos y de las operaciones que manipulan esos
datos.
1.1.2. Mensajes y métodos
► Mensaje: Para ordenar a una clase o a un objeto que realice una tarea,
se le envía un mensaje. Para que una clase u objeto procese el mensaje,
debe ser programado en forma adecuada. No se puede simplemente
mandar un mensaje a cualquier clase u objeto. Solo se puede mandar un
mensaje a las clases y objetos que entienden el mensaje que se les envía.
Optativa I – Java Introducción
Prof. Adan Morel
6
► Método: Para que una clase u objeto procese el mensaje que recibe,
debe poseer un método compatible, que es una secuencia de
instrucciones que una clase u objeto sigue para realizar una tarea.
Un método definido para una clase se llama método de clase y un método
definido para un objeto es un método de instancia.
Un ejemplo de método de instancia seria, suponer que se define un método
llamado “caminar” para un objeto “Robot”, al cual se le ordena que camine una
distancia designada. Con este método definido, se puede enviar el mensaje
caminar a un objeto Robot, junto con la distancia que debe avanzar.
Un valor que pasamos a un objeto se llama “Argumento” de un mensaje. El
nombre del mensaje que se envía a un objeto o a una clase debe ser el mismo
que el nombre del método.
2. Clases e instancias de valores de datos
Supongamos que el método depósito de un objeto “Cuenta” ordena al objeto que
agregue una cantidad determinada al saldo actual. ¿Dónde mantiene el objeto el
saldo actual? Recuerde que un objeto está compuesto de valores de datos y
métodos. De manera parecida a como se definen los métodos de clase e
instancia, se pueden definir los valores de datos de clase instancia. Por ejemplo,
se define un Valor de datos de instancia saldo actual para objetos Cuenta al
registrar el saldo actual.
Juan: cuenta
María: cuenta
Pedro: cuenta
Saldo actual
908.55
Saldo actual
1304.9
Saldo actual
354.00
Optativa I – Java Introducción
Prof. Adan Morel
7
En esta figura muestra 3 objetos Cuenta con sus valores de datos saldo actual.
Observe que todos tienen los mismos valores de datos saldo actual. Todas las
instancias de la misma clase tendrán el mismo conjunto de valores de datos. Las
cantidades reales de dólares para el saldo actual, como ilustra el diagrama, son
diferentes entre una instancia y otra. Los temas como saldo de apertura y número
de cuenta son otros valores de datos de instancia posibles para los objetos
Cuenta.
Un Valor de datos de clase se usa para representar la información compartida
por todas las instancias o para representar la información colectiva acerca de las
instancias, por ejemplo si cada cuenta debe mantener un saldo mínimo de,
digamos, $100, se puede definir un valor de datos de clase llamado saldo
mínimo. Una instancia puede tener acceso a los valores de datos de clase del
tipo al que pertenece, de tal forma que cada objeto Cuenta puede tener acceso
al valor de datos de clase saldo mínimo.
3. Ingeniería de software y ciclo de vida del
software
Cuando decimos programación computacional, nos referimos no solo a escribir
comandos de Java, sino también a todo un proceso de desarrollo de un software.
Conocer solo un lenguaje de programación no es suficiente para llegar a ser un
creador competente software. Debe saber cómo diseñar un programa.
Una casa se construye en etapas bien definidas y se aplican principios de
ingeniería en todas las etapas. De forma similar, un programa se construye en
etapas y se aplica metodología disciplinada en todas las etapas del desarrollo
del mismo.
► Ciclo de vida del software: es la secuencia de etapas desde la
concepción hasta la operación de un programa.
Optativa I – Java Introducción
Prof. Adan Morel
8
► Ingeniería de software: es la aplicación de un método sistemático y
disciplinado al desarrollo, prueba y mantenimiento de un programa.
Hay cinco fases principales en el ciclo de vida de un
software:
► ANÁLISIS: en esta fase se realiza un estudio de factibilidad. Se analiza
el problema y se determina si es posible una solución. Suponiendo que
sea posible una solución, el resultado de esta fase es una especificación
de requisitos que describe las características de un programa, las cuales
deben ser descritas de tal forma que sean probables.
► DISEÑO: en esta fase se pasa una especificación de requisitos a un
diseño detallado del programa. Para un diseño orientado a objetos, el
resultado de esta fase será un conjunto de clases que cumplan con los
requisitos.
► CODIFICACIÓN: en esta fase se implementa un diseño en un programa
real. Una vez que tenemos un diseño bien construido, implementarlo en
un código real no es tan difícil.
► PRUEBA: en esta fase se ejecuta el programa usando diferentes grupos
de datos para verificar que el programa se ejecuta de acuerdo con la
especificación.
Existen dos tipos de prueba:
o Pruebas de unidad: verifican las clases de forma individual.
o Pruebas de Integración: demuestra que las clases funcionen juntas
de manera correcta.
 Depuración: es la actividad que se realiza para eliminar los errores
de programación. Un error podría ser el resultado de fallar en la
implementación o el diseño. Cuando hay un error, se tiene que
retroceder a las fases anteriores para eliminarlo.
Optativa I – Java Introducción
Prof. Adan Morel
9
► OPERACIÓN: en esta fase el programa estará listo para usarse. La
actividad más importante y que ocupa más tiempo durante esta fase es el
“Mantenimiento del software”, que significa hacer cambios al software. Se
calcula que el 70% del costo del software se relaciona con el
mantenimiento del mismo. Por lo tanto, es natural que cuando
desarrollamos un software, nos propongamos uno que sea fácil de
mantener.
4. Componentes del programa
Un programa en Java, se compone de:
Comentarios
Un comentario es cualquier secuencia de texto que comienza con el marcador /*
y termina con otro marcador */.
Los Marcadores del comentario inicial y final coinciden en pares. Cada
marcador de inicio debe tener un marcador final que coincida. Cualquier
marcador inicial que aparezca entre el marcador inicial y final correspondiente
se trata como parte del comentario. En otras palabras, no se puede poner un
comentario dentro de otro comentario.
/*
Este es un comentario
Con tres líneas
De texto
*/
Un Marcador del comentario de una sola línea. Cualquier texto entre el
marcador de doble diagonal y el final de la línea es un comentario.
//Este eso un comentario
Optativa I – Java Introducción
Prof. Adan Morel
10
//Este es otro comentario
//Este es un tercer comentario
El tercer tipo de comentario se llama Comentario javadoc. Es un comentario
especializado que puede aparecer antes de la declaración de clase y de otros
elementos del programa.
Sentencia import (de importación)
Se desarrollan programas orientados a objetos al usar clases predefinidas,
definidas tanto por el sistema como por el programador, siempre que sea posible
y al definir nuestras propias clases cuando no haya clases predefinidas
adecuadas disponibles.
En Java las clases se agrupan en paquetes y el sistema Java viene con
numerosos paquetes. También se pueden agrupar en forma lógica las propias
clases del programador en un paquete de tal manera que puedan reutilizarse
convenientemente en otros programas.
Para usar una clase a partir de un paquete, nos referimos a la clase de nuestro
programa usando el siguiente formato:
<nombre del paquete>.<nombre de la clase>Esta notación se llama notación
de punto.
Un paquete puede incluir subpaquetes que formen una jerarquía de paquetes.
Al referirnos a una clase de un paquete profundamente anidado, usamos
múltiples puntos, por ejemplo:
javax.swing.JFrame
Optativa I – Java Introducción
Prof. Adan Morel
11
Para referirnos a la clase JFrame del paquete javax.swing; esto es, el paquete
swing esta dentro del paquete javax. La notación punto con los nombres de todos
los paquetes a los que pertenece una clase se llama nombre completamente
calificado de la clase. Usar el nombre completamente calificado de una clase
es con frecuencia muy engorroso, en especial cuando debemos referirnos a la
misma clase muchas veces en un programa. Podemos usar la sentencia import
para evitar este problema.
La sentencia import permite que el programa se refiera a clases definidas en el
paquete designado sin usar el nombre de la clase completamente calificado.
Si necesitamos importar más de una clase de un mismo paquete, entonces en
vez de usar una sentencia import para cada clase podemos importarlos todos al
usar una notación de asterisco:
Import javax.swing.*
Declaración de clase
Un programa se compone de una o más clases; algunas son clases predefinidas,
mientras que otras las definimos nosotros. Para definir una nueva clase,
debemos declararla en el programa o hacer una declaración de clase.
class <nombre de la clase> {
<declaración de miembros de la clase>}
► Clase principal: una de las clases de un programa debe designarse como
la clase principal.
Si designamos una clase como la clase principal, entonces debemos
definir un método llamado main (principal) porque cuando se ejecuta un
Optativa I – Java Introducción
Prof. Adan Morel
12
programa de java, se ejecuta primero el método main de una clase principal.
Para definir un método debemos declararlo en una clase.
► Declaración de método:
La sintaxis para la declaración de método es
<modificadores><tipo de retorno> <nombre del método>
(<parámetros> {
<cuerpo del método>
}
En donde <modificadores> es una secuencia de términos que designan
diferentes clases de métodos, <tipo de retorno> es el tipo de valor de datos que
regresa el método, <nombre del método> es el nombre del método,<parámetro>
es una secuencia de los valores que se pasan al método y <cuerpo del método>
es una secuencia de instrucciones.
5. Ciclo editar – Compilar - Ejecutar
PASO 1
Escriba el programa en el editor y guárdelo en un archivo. Use el nombre de la
clase principal y el sufijo .java para el nombre del archivo. Este archivo, en el que
el programa está en una forma legible para las personas, se llama archivo
fuente.
Import javax.swing.*;
class ejemplo {
Optativa I – Java Introducción
Prof. Adan Morel
13
public static void main(String [] args ) {
JFrame miventana;
miventana = new JFrame ();
miventana.setSize(300,200);
miventana.setTitle(“Mi primer programa Java”);
miventana.setVisible(true);
}}
PASO 2
Compile el archivo fuente. Muchos compiladores requieren que se cree un
archivo de proyecto y después que se coloque el archivo fuente en dicho
archivo del proyecto con la finalidad de compilar el archivo fuente.
Cuando la compilación es exitosa se crea la versión compilada del archivo
fuente. Esta versión compilada se llama bytecode (código byte) y el archivo
que contiene el código byte se llama archivo en bytecode.
El nombre del archivo en bytecode generado por el compilador tendrá el sufijo
.class, mientras que su prefijo es el mismo que el del archivo fuente.
Optativa I – Java Introducción
Prof. Adan Morel
14
15
Imagen proveída por el docente
Cuando ocurre cualquier error en un programa, se desplegara un mensaje de
error. Si el programa no contiene errores en la sintaxis, entonces en lugar de un
mensaje de error, no aparecerá nada o lo hará un mensaje que dirá algo como
“Compiled successfully” (“Compilación exitosa”).
Para ver qué tipo de mensajes de error se despliegan, intente compilar el
siguiente programa. Se introdujeron tres errores a propósito; ¿Los puede
encontrar?
Import javax.swing.*;
class ejemplo {
public static void main(String [] args ) {
miventana = new JFrame ();
miventana.setSize();
miventana.setTitle(“Mi primer programa Java”);
Optativa I – Java Introducción
Prof. Adan Morel
miventana.setVisible(true)
}
}
► Errores de compilación: son los errores detectados por el compilador,
los cuales son de hecho los tipos de error más fáciles de corregir. La
mayoría de los errores de compilación se deben a la violación de las
reglas de sintaxis.
PASO 3
Ejecute el archivo en bytecode. Un intérprete java ira a través del archivo en
bytecode y ejecutara las instrucciones en él. Si su programa está libre de errores,
aparecerá una ventana en la pantalla.
Imagen proveída por el docente
► Errores de ejecución: son errores detectados por el intérprete. Si ocurre
un error en la ejecución del programa, el intérprete lo atrapara y detendrá
la ejecución.
Optativa I – Java Introducción
Prof. Adan Morel
16
Algunas clases estándar en Java
Antes de llegar a ser un experto en definir sus propias clases, debe aprender
cómo usar las existentes.
1. SALIDA ESTANDAR
Cuando un programa calcula un resultado, se necesita una forma de que muestre
este resultado al usuario del programa. Una de las formas más comunes de
hacerlo en java es usar la ventana de consola, la cual también se llama ventana
de salida estándar.
Producimos datos que son los resultados del cálculo o mensajes a la ventada de
consola a través de System.out. La clase System incluye una cantidad de
valores útiles de datos de clases. Uno es una instancia de la clase PrinStream
llamado out. Puesto que este es un valor de datos de clase, nos referimos a él a
través del nombre de clase como System.out y este objeto PrintStream se vincula
con la ventana de la consola (existe exactamente una ventana de consola por
programa).
Cada elemento de dato que enviamos a System.out aparecerá en esta ventana
de consola. A la técnica de producir datos usando System.out la llamamos salida
estándar.
System.out.print (“HOLA MUNDO”);
2. CLASE STRING
Los valores textuales que pasamos al método print o el constructor de la clase
JFrame son instancias de la clase String (cadena). Una secuencia de caracteres
encerrados por doble entrecomillado es constantes String. Como String es una
clase, podemos crear una instancia y darle un nombre.
Optativa I – Java Introducción
Prof. Adan Morel
17
String Nombre;
18
Nombre= new String (“Juan Lopez”);
A diferencia de otras clases, el uso explícito de new para crear una instancia es
opcional para la clase String. Se puede crear un nuevo objeto String de esta
forma:
String Nombre;
Nombre= “Juan Lopez”;
Existen cerca de 50 métodos definidos en la clase String. Estos son 3 de ellos:
► Substring: extrae una subcadena dada al especificar las posiciones de
inicio y fin.
String texto;
press
texto = “Espresso”;
System.out.print (texto.substring(2,7));
► Length: devuelve el número de caracteres en un objeto String. Usando el
ejemplo anterior:
8
texto.length ();
► indexOf: localiza la posición de una subcadena dentro de otra cadena.
Por ejemplo, si el identificador texto se refiere a la cadena “Hola mundo”.
texto.indexOf(“mundo”)
5
Regresara el valor 5, que es la posición del primer carácter de la cadena
designada mundo. Si la cadena buscada no se localiza en la cadena, entonces
regresa -1.
Optativa I – Java Introducción
Prof. Adan Morel
3. DATE Y SIMPLEDATEFORMAT
19
La clase Date (fecha) se usa para representar una instancia de tiempo con la
precisión de un milisegundo (una milésima de segundo). Esta clase está en el
paquete java.util. Cuando se crea un nuevo objeto Date, se establece en la hora
en el que se crea (la hora actual se determina por la lectura de la hora que
mantiene el sistema operativo en su máquina).
La clase Date incluye el método toString que convierte su formato interno en una
representación de cadena, que se puede usar para desplegar la hora. Por
ejemplo:
Date hoy;
Wed Jan 28 15:05:18 PDT 2006
hoy = new Date()
System.out.println (hoy.toString ());
4. ENTRADA ESTANDAR
Análogo a la salida System.out tenemos System.in para la entrada. Llamamos a
la técnica para introducir datos usando System.in entrada estándar. System.in
acepta entradas desde el teclado. También usamos el término console input
(entrada de consola) para referirnos a las entradas estándar. Usar System.in
para las entradas es un poco más complicado que usar System.out para las
salidas. System.in es una instancia de la clase InputStream que proporciona solo
la facultad de introducir un byte a la vez con su método read (leer). Sin embargo,
se requieren múltiples bytes para representar tipos comunes de datos, así como
las cadenas.
La clase Scanner del paquete java.util proporciona una facilidad de entrada
necesaria para acomodar varias rutinas de entrada.
Optativa I – Java Introducción
Prof. Adan Morel
Import java.util.*;
20
…
Scanner escáner;
escaner = new Scanner (System.in);
Ejemplo de desarrollo
Ahora que adquirimos un conocimiento básico de los programas de aplicaciones
de Java, escribamos una nueva aplicación. Ya que el programa que crearemos
aquí es muy sencillo, podemos escribirlo sin pasar por las fases de diseño,
codificación y prueba del ciclo de vida del software. Sin embargo, es muy
importante que usted se introduzca en el hábito desarrollar un programa
siguiendo las etapas del ciclo de vida del software.
Generaremos este programa mediante una técnica de desarrollo incremental,
que elaborara el programa en pequeños pasos graduales. Comenzamos con un
programa muy limitado y en forma gradual desarrollaremos el programa al
agregarle más y más códigos. En cada caso incremental diseñamos, codificamos
y probamos el programa antes de movernos al siguiente paso. Este desarrollo
metódico de un programa nos permite enfocar nuestra atención en una sola tarea
en cada paso y esto reduce la oportunidad de introducir errores en el programa.
► Enunciado del problema
Escriba una aplicación que requiera el nombre y apellido del usuario y que
conteste con las iniciales del usuario.
► Plan global
Tareas del programa:
Optativa I – Java Introducción
Prof. Adan Morel
1. Obtener el nombre y apellidos del usuario
21
2. Extraer las iniciales para formular un monograma
3. Presentar el monograma
Documento de diseño: Monograma
Clase
Propósito
Monograma
La clase principal del programa.
Scanner
El método next se usa para obtener el nombre completo.
String
La clase se usa para manipulación de cadenas y para
extraer iniciales
Del nombre y de los apellidos.
(PrintStream)
La ventana de salida estándar se usa para desplegar el
System.out
monograma resultante.
Pasos del desarrollo
1. Comience con la planilla del programa y añada el código para obtener
entrada.
2. Añada el código para calcular y mostrar el monograma.
Desarrollo del PASO 1: obtener entrada.
El problema dice que el programa tiene como entrada el nombre del usuario y
mostrara sus iniciales. No específica como, así que en la etapa de diseño
decidiremos como hacer esto. Ya que en este punto conocemos solo una forma
de ingresar datos, que es usar la clase Scanner, la usaremos aquí. Pero ¿de qué
Optativa I – Java Introducción
Prof. Adan Morel
forma debemos introducir estos tres datos? Hay dos alternativas de diseño
posibles.
► Diseño alternativo 1
En el primer diseño, las introduciremos en forma separada.
String Nombre, apellidoP, apellidoM;
Scanner escáner = new Scanner(System.in);
System.out.print(“Nombre: ”);
Nombre = escaner.next ( );
System.out.print(“Apellido paterno: ”);
apellidoP= escáner.next( );
System.out.print(“Apellido Materno: ”);
apellidoM= escaner.next( );
► Diseño alternativo 2
String nombreCompleto;
Scanner escaner = new Scanner(System.in);
escaner.useDelimiter(System.getProperty(“line.separator”));
System.out.print(“Nombre Completo: ”);
nombreCompleto = escaner.next( );
¿Qué diseño es mejor? Nunca hay ”una respuesta correcta” a los problemas de
diseño. Debemos seleccionar una de las alternativas posibles que satisfagan los
diferentes criterios de la forma más efectiva en una situación dada.
Optativa I – Java Introducción
Prof. Adan Morel
22
Los criterios pueden incluir las necesidades y preferencias del usuario, el
desempeño más rápido, los costos de desarrollo, las restricciones de tiempo y
otros factores.
En el este caso escogemos el segundo enfoque porque el usuario introduce los
datos más rápidamente a través de un solo diálogo.
► Prueba del paso 1
Después de escribir el programa, lo probamos para verificar que se ejecuta como
se desea. La ejecución exitosa de este programa verifica que la configuración
del programa está bien, que se importan los paquetes necesarios y que los
objetos se declaran en forma correcta.
Desarrollo del PASO 2: calcular y mostrar el monograma
La siguiente tarea es extraer las iniciales de la cadena de entrada. Primero,
debido a nuestro conocimiento limitado de programación en este punto,
supondremos que la entrada es correcta. Esto es, la cadena de entrada contiene
nombre y dos apellidos y están separados solo por un espacio en blanco.
Segundo hay muchas soluciones posibles, pero resolveremos este problema
usando solo los métodos que ya hemos tratado. Sabemos que una secuencia de
métodos de indexOf y substring puede dividir una cadena (nombre completo) en
dos subcadenas (nombre y apellido).
Una vez que dividimos el nombre de entrada en nombre y dos apellidos, extraer
las iniciales es una aplicación bastante sencilla del método indexOf. Podemos
extraer la primera letra de una cadena:
Cadena.substring (0,1)
Y el monograma se puede formular al concatenar las tres iniciales como
nombre.substring (0,1)
+apellidoP.substring (0,1)
Optativa I – Java Introducción
Prof. Adan Morel
23
+apellidoM.substring (0,1)
24
► Idea General
String nombre;
nombre= “Jon Jay Java”;
Jon Jay Java
Jon
Jay Java
Jay
Java
Este es nuestro código:
Import java.util.*
class Monograma {
public static void main(String[] args) {
String nombreCompleto;
Scanner escaner = new Scanner(System.in);
escaner.useDelimiter(System.getProperty(“line.separator”));
System.out.print(“Nombre Completo: ”);
nombreCompleto = escaner.next( );
System.out.println(“Nombre ingresado: “+ nombreCompleto);
}
}
Optativa I – Java Introducción
Prof. Adan Morel
► Prueba del paso 2
25
Para verificar que el cómputo está funcionando en forma correcta, ejecutamos el
programa varias veces e introducimos diferentes nombres.
Recuerde que
suponemos que no hay error en la entrada; esto es, el nombre y los dos apellidos
están separados por un espacio en blanco.
Variables
Se denominan variables a las localidades de memoria a los que se asocian los
valores determinados, cualquier identificador valido puede ser usado como un
nombre de variable.
Una variable tiene 3 propiedades: una localidad de memoria para almacenar el
calor, el tipo de datos almacenados en la localidad de memoria y el nombre
usado para referirse a la localidad de memoria.
La sintaxis general para declarar las variables es <tipo de dato> <variables>, en
donde <variables> es una secuencia de identificadores separados por comas.
Cada variable que usemos en un programa debe declararse. Podemos tener
tantas declaraciones como queremos. Sin embargo, no podemos declarar la
misma variable más de una vez, por lo tanto una segunda declaración de una
misma variable no es válida.
Supongamos que queremos calcular la suma y la resta de dos números.
Llamemos a los dos números X e Y. en matemáticas, decimos
X+Y
ó
X-Y
Para calcular la suma y la resta de estos en un programa, primero debemos
declarar que tipo de datos les asignaremos. Después de asignarles valores,
podemos calcular su suma y su resta.
Digamos que X e Y son números enteros. Para declarar que el tipo de datos
asignado a ellos es un número entero escribimos
Optativa I – Java Introducción
Prof. Adan Morel
int
x, y;
26
Después de hacer la declaración podemos asignar solo números enteros a estas
variables, no podemos asignarles números reales.
TIPO DE
VALOR
CONTENIDO
DATOS
VALOR MINIMO
VALOR MAXIMO
PREDETERMINADO
byte
Entero
0
-128
127
short
Entero
0
-32768
32767
int
Entero
0
-2147483648
2147483647
long
Entero
0
-9223372036854775808
9223372036854775807
float
Real
0.0
-3.40282347E+38
3.40282347E38
double
Real
0.0
-1.7976931346231570E+308
1.79769313486231570E+308
Existen 6 tipos de datos en Java: byte, short, int, long, float, y double. La
diferencia entre estos tipos de datos está en el rango de valores que puedan
representar, como se muestra en la tabla que veremos a continuación.
La única diferencia entre una variable para números y una variable para objetos
es el contenido en las localidades de memoria. Para los números, una variable
contiene el valor numérico en sí mismo y para los objetos, una variable contiene
una dirección en donde se almacena el objeto. Los nombres de los objetos son
sinónimos de las variables cuyos contenidos son referencias a objetos (es decir,
direcciones de memoria).
Optativa I – Java Introducción
Prof. Adan Morel
Expresiones aritméticas
Una expresión que involucra valores numéricos como 23 + 45 se llama expresión
aritmética porque consiste en operadores y operandos aritméticos. Un operador
aritmético, como + en el ejemplo designa un cálculo numérico.
► Un operando en expresiones aritméticas puede ser una constante, una
variable, una llamada a método u otra expresión aritmética, posiblemente
colocada entre paréntesis.
► Un operador binario es aquel el cual opera con dos operandos. Ejemplo:
x + 4. Todos los demás operadores aritméticos excepto el menos también
son operadores binarios. Los operadores menos y más pueden ser tanto
binarios como unitarios.
Reglas para la promoción aritmética.
Operador unitario.
► Si el operando es del tipo byte o short, entonces se convierte en int.
► De otra forma, el operando permanece del mismo tipo.
Operador binario.
► Si cualquiera de los operandos es del tipo doublé entonces el otro
operando se convierte a double.
► De otra manera, si cualquiera de los operandos es del tipo float, entonces,
el otro operando se convierte en float.
► De otra forma, si cualquiera de los operandos es del tipo long, entonces
el otro se convierte a long.
► De otra manera, ambos operandos se convierten a int.
Si deseamos asignar un mismo valor a múltiples variables, podemos escalonar
las operaciones de asignación como:
X=Y=1;
Optativa I – Java Introducción
Prof. Adan Morel
27
Lo que es equivalente a decir:
X=1;
Y=1;
El símbolo de asignación = es de hecho un operador y su orden de precedencia
es más bajo que el de los demás operadores. Los operadores de asignación se
evalúan de derecha a izquierda.
Constantes
Mientras se ejecuta un programa, se pueden asignar valores distintos a una
variable en diferentes tiempos (de ahí el nombre variable, puesto que los valores
que contienen pueden variar), pero en algunos casos no queremos que esto
suceda. En otras palabras queremos bloquear el valor asignado de manera que
no pueda ocurrir cambio alguno. Una constante se declara de forma similar a la
variable pero con la palabra reservada adicional final.
Una variable debe asignársele un valor en el momento de su declaración. Aquí
hay un ejemplo de declaración de cuatro constantes:
final double PI = 3.14159;
final short CONSTANTE_FARADAY = 23060 //unidad: cal/volt
final double CM_POR_PULGADA = 2.54;
final int MESES_EN_EL_ANIO = 12;
Despliegue de valores numéricos.
Así cómo podemos desplegar los valores cadena para la ventana de la consola
usando System.out. también podemos desplegar con facilidad valores numéricos
en la ventana de la consola. Usaremos los mismos métodos print y println para
Optativa I – Java Introducción
Prof. Adan Morel
28
desplegar valores numéricos. Aquí hay un ejemplo sencillo que despliega los
valores de una constante y una variable:
Int num = 15;
System.out.print (num); //escribe una variable
System.out.print (“ “);//escribe un espacio en blanco
System.out.print(10);//escribe una constante
Al ejecutar el código dará por resultado la siguiente ventana de consola:
15 10
Podemos usar el método println para saltarnos una línea después de imprimir el
valor. Al ejecutar
Int num= 15;
System.out.println (num);
System.out.println (10);
Que dará por resultado:
15
10
Al usar el método de concatenación, es posible producir valores múltiples con un
solo método print o println. Por ejemplo:
System.out.print (30 + “ “ + 40);
Es equivalente a
System.out.print (30);
System.out.print (“ “);
Optativa I – Java Introducción
Prof. Adan Morel
29
System.out.print (40);
30
Observe que la expresión 30 + “ “ + 40 mezcla valores numéricos y una cadena.
El símbolo “+ (mas)” se usa para concatenar cadenas, pero además de poder
hacer esto con las cadenas también se puede usar para poder añadir valores
numéricos. El símbolo “+ (mas)” por lo tanto, podría significar dos cosas
diferentes: concatenación de cadenas o suma algebraica.
La clase Math
Usar solo operadores aritméticos para expresar cálculos numéricos es muy
limitante. Muchos cálculos requieren el uso de funciones matemáticas. Por
ejemplo el uso de expresiones que requieran hacer cálculos de funciones
trigonométricas o de la raíz cuadrada, etc.
La clase Math del paquete java.lang contiene los métodos de la clase para las
funciones matemáticas usadas comúnmente. Además también esta clase
contiene dos constantes que son el PI ( ) y e para el numero natural e,
respetivamente.
Imagen proveída por el docente
Optativa I – Java Introducción
Prof. Adan Morel
Generación de números aleatorios
En muchas aplicaciones de computadoras, en especial de simulación y juegos,
hay que generar números aleatorios. Por ejemplo, para simular un lanzamiento
de dados, podemos generar un número entre 1 y 6. Para dicho efecto
utilizaremos el método random de la clase Math.
El generador de números seudoaleatorios o como se lo conoce random devuelve
un numero de tipo double. El número generado se llama número seudoaleatorio
porque el número no es verdaderamente aleatorio. Cuando llamamos a este
método en forma repetida, al final los números se repetirán a sí mismos. Por lo
tanto, de manera teórica, los números generados no son aleatorios, pero para
propósitos prácticos, son lo suficientemente aleatorios.
Los números aleatorios que queremos generar para la mayoría de los propósitos
y de las aplicaciones son números enteros.
Escribamos un programa corto que seleccione un ganador entre los asistentes a
una fiesta del baile anual de primavera de la fraternidad. Los asistentes recibirán
los números M+1, M+2, M+3, etc., conforme entren en la casa. El valor inicial M
lo selecciona el presidente del comité de la fiesta. El ultimo numero asignado es
M + N si es que hay N número de asistentes. Al final de la fiesta, ejecutamos el
programa que de manera aleatoria seleccionara el numero ganador en un rango
de M+1 y M+N.
Import java.util.*;
class SeleccionaGanador{
public static void main (String[] args){
int numInicial;
//número inicial
int contador;
//número de asistentes a la fiesta
Optativa I – Java Introducción
Prof. Adan Morel
31
int numGanador;
//el ganador
int min, max;
//el rango de números aleatorios a
32
generar
Scanner escan= new Scanner(System.in);
//Obtiene dos valores de entrada
System.out.print(“Ingresa numero inicial M:
”);
numInicial=escan.nextIn();
System.out.print (“Ingresa numero de asistentes:
“);
Contador= escan.nextIn();
//selecciona al ganador
min = numInicial + 1;
max = numInicial + contador;
numGanador = (int) (Math.floor(Math.random() * (max – min + 1))
System.out.println(“\nEl numero ganador es “ + numGanador);
}
}
La clase gregoriancalendar
Esta es otra clase muy útil en la manipulación de la información de calendario
como año, mes y día llamada java.util.GregorianCalendar. Podemos crear un
nuevo objeto que represente hoy como:
GregorianCalendar hoy= new GregorianCalendar ( );
Optativa I – Java Introducción
Prof. Adan Morel
O un día en específico, digamos, 3 de junio de 1994, al pasar año, mes y dia
como los parámetros:
GregorianCalendar día= new GregorianCalendar(1994, 5, 3);
El valor 5 representa al mes de Junio, el primer mes del año, enero, se representa
con el 0, el segundo mes con el 1 y así sucesivamente. Para evitar confusión,
podemos usar constantes definidas para los meses en la superclase Calendar
(GregorianCalendar es una subclase de Calendar). En lugar de recordar que el
valor 5 representa al mes de junio, podemos usar la constante Calendar.JUNE
como GregorianCalendar día= new GregorianCalendar(1994, Calendar.JUNE,
4);
► Constantes definidas en la clase Calendar para diferentes piezas
recuperadas de la información calendario/hora.
Constante
Descripción
AÑO
La parte del año de la fecha del calendario
MES
La parte del mes de la fecha del calendario
FECHA
El día del mes
DIA_DEL_MES
Igual que FECHA
DIA_DEL_AÑO
El número del día dentro del año
DIA_DEL_MES
El número del día dentro del mes
DIA_DE_LAS_SEMANA El día de la semana (Sun-1, Mon-2,etc.)
SEMANA_DEL_AÑO
El número de la semana dentro del año
SEMANA_DEL_MES
El número de la semana dentro del mes
AM_PM
El indicador para AM o PM (AM- 0 y PM -1)
Optativa I – Java Introducción
Prof. Adan Morel
33
HORA
La hora en una notación de 12 horas
HORA_DEL_DIA
La hora en una notación de 24 horas
MINUTO
El minuto dentro de la hora
Representación numérica
Los fabricantes de computadoras han usado varios formatos para almacenar los
valores numéricos, el criterio actual es usar el formato complemento a dos para
almacenar números enteros y el formato de punto flotante para números reales.
► Bit de signo: con 8 bits, podemos representar números positivos de 0 a
255. El posible rango de números negativos y positivos que podemos
representar, usando 8 bits. Podemos designar el bit que este en el
extremo izquierdo como un bit de signo: 0 significa positivo y 1 negativo.
Con esta combinación podemos representar números enteros de -127 a
+127 como se muestran en la siguiente tabla.
Numero binario de 8bits (con un bit de
Equivalente
signo)
decimal
0 0000000
+0
0 0000001
+1
0 0000010
+2
…
…
Optativa I – Java Introducción
Prof. Adan Morel
34
0 1111111
+127
1 0000000
-0
…
…
1 1111110
-126
1 1111111
-127
► Punto flotante: aquí solo presentamos las ideas básicas para almacenar
números reales en la memoria de la computadora. Omitimos los detalles
precisos del Criterio 754 del Institute of Electronics and Electrical Engineer
(IEEE) que es el que usa Java para almacenar números reales.
Los números reales se representan en la computadora al usar notación
científica. En la notación científica con base 10, un número real se expresa
como
A x 10N
En donde A es un número real y N es un exponente integral. Por ejemplo,
la masa atómica del hidrogeno (en gramos) se expresa en notación
científica decimal como 1.67339
x 10-24,
lo
que es igual a
0.000000000000000000000000167339.
Usamos una notación científica con base 2 para almacenar números
reales en la memoria de la computadora. La notación científica con base
2 representa un número real como sigue:
A x 2N
Optativa I – Java Introducción
Prof. Adan Morel
35
Bibliografía
► Deitel, H., & Deitel, P. (2004). Como Programar Java. Mexico: Prentice
Hall.
► Holzner, S. (2000). LA BIBLIA DE JAVA 2. MADRID: ANAYA
MULTIMEDIA.
► Wu, C. T. (2001). Programación en Java. Madrid: MCGRAW-HILL.
Optativa I – Java Introducción
Prof. Adan Morel
36