Documentos de Académico
Documentos de Profesional
Documentos de Cultura
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 2
Introducción: ................................................................................................................. 3
Desarrollo ..................................................................................................................... 4
Comentarios .......................................................................................... 10
Variables..................................................................................................................... 25
Constantes ................................................................................................................. 28
Bibliografía .................................................................................................................. 36
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
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.
Desarrollo
► 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.
Comentarios
/*
Este es un comentario
De texto
*/
Para usar una clase a partir de un paquete, nos referimos a la clase de nuestro
programa usando el siguiente formato:
javax.swing.JFrame
Import javax.swing.*
Declaración de clase
► Declaración de método:
(<parámetros> {
PASO 1
Import javax.swing.*;
class ejemplo {
JFrame miventana;
miventana.setSize(300,200);
miventana.setVisible(true);
}}
PASO 2
Import javax.swing.*;
class ejemplo {
miventana.setSize();
PASO 3
Antes de llegar a ser un experto en definir sus propias clases, debe aprender
cómo usar las existentes.
1. SALIDA ESTANDAR
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).
2. CLASE STRING
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;
String texto;
press
texto = “Espresso”;
System.out.print (texto.substring(2,7));
texto.indexOf(“mundo”) 5
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()
4. ENTRADA ESTANDAR
Scanner escáner;
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.
Escriba una aplicación que requiera el nombre y apellido del usuario y que
conteste con las iniciales del usuario.
► Plan global
Clase Propósito
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é
► Diseño alternativo 1
System.out.print(“Nombre: ”);
Nombre = escaner.next ( );
apellidoP= escáner.next( );
apellidoM= escaner.next( );
► Diseño alternativo 2
String nombreCompleto;
escaner.useDelimiter(System.getProperty(“line.separator”));
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.
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)
nombre.substring (0,1)
+apellidoP.substring (0,1)
► Idea General
String nombre;
Jay Java
Import java.util.*
class Monograma {
String nombreCompleto;
escaner.useDelimiter(System.getProperty(“line.separator”));
nombreCompleto = escaner.next( );
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.
X+Y ó X-Y
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
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).
Operador unitario.
Operador binario.
X=Y=1;
X=1;
Y=1;
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.
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
15 10
Podemos usar el método println para saltarnos una línea después de imprimir el
valor. Al ejecutar
System.out.println (num);
System.out.println (10);
15
10
Es equivalente a
System.out.print (30);
System.out.print (“ “);
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.
Los números aleatorios que queremos generar para la mayoría de los propósitos
y de las aplicaciones son números enteros.
Import java.util.*;
class SeleccionaGanador{
numInicial=escan.nextIn();
Contador= escan.nextIn();
//selecciona al ganador
min = numInicial + 1;
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:
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);
Constante Descripción
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.
0 0000000 +0
0 0000001 +1
0 0000010 +2
… …
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
► Deitel, H., & Deitel, P. (2004). Como Programar Java. Mexico: Prentice
Hall.