1. Introduccion Java

UAA – Sistemas Electrónicos Programación en Java Eduardo Serna-Pérez

1

1 Introducción al Lenguaje Java La orientación a objetos puede percibirse desde dos puntos de vista, como una metodología de diseño de software o como un paradigma de programación, donde se definen a los programas en términos de "clases de objetos", estos objetos son entidades que combinan su estado (es decir, datos) y su comportamiento (esto es, procedimientos o métodos). La programación orientada a objetos (POO) expresa un programa como un conjunto de éstos elementos, que se comunican entre ellos para realizar tareas. Esto difiere de los lenguajes procedurales tradicionales, en los que los datos y los procedimientos están separados y sin relación. La POO está pensada para hacer programas más fáciles de organizar, mantener y reutilizar, ya que anima al programador a pensar los programas en términos de tipos de datos, y en segundo lugar en las operaciones específicas para esos tipos de datos.

1.1 Orígenes de Java El primer lenguaje de programación orientado a objetos fue Simula, creado en la década de 1960´s por Kristen Nygaard (Figura 1) y Ole-Johan Dahl (Figura 2), del Centro de Computación Noruego, fue desarrollo para apoyar la modelación de simulaciones de eventos discretos en procesos científicos e industriales, mediante la representación directa de objetos del mundo real.

Figura 1: Kristen Nygaard Figura 2: Ole-Johan Dahl

Con Simula I (1961 al 65) y Simula 67, Nygaard y Dahl introducían los conceptos bajo los cuales más tarde todos los lenguajes de programación orientada a objetos serian construidos: objetos, clases, herencia, cuantificador virtual y ejecución de programas multi-hilo. El término Orientado a Objetos fue acuñado por Alan Kay (Figura 3) en la década de los 1970´s, así mismo, él es considerado también como uno de los creadores del modelo orientado a objetos. Alan Kay desarrollo mejoras sustánciales al modelo de programación, generando un lenguaje llamado Smalltalk que era un sistema completamente dinámico en el cual las clases pueden ser creadas y modificadas dinámicamente.


2

En la primera mitad de la década de los ochenta la POO se convirtió en una metodología de programación dominante debido principalmente a la influencia de Smalltalk. Su dominancia fue completamente cimentada por el surgimiento de las Interfaces gráficas de usuario (GUI´s) desarrolladas principalmente en Smalltalk, para lo cual la orientación a objetos es decididamente la mejor opción. A partir de este punto, se desarrollaron más lenguajes de programación de este tipo entre los que destacan Objective-C (Brad Cox), C++ (Bajarn Stroustrup), Eiffel (Bertrand Meyer), Oberon de Niklaus Wirth (Figura 4), Java y ya más recientemente Python, Ruby, Perl, PHP, C# y la plataforma de .NET.

Figura 3: Alan Kay Figura 4: Niklaus Wirth

A continuación se explican los puntos más importantes relacionados con éste paradigma de programación y las bases en las que se sustenta su funcionamiento y metodología.

1.1.1 Conceptos básicos de orientación a objetos El paradigma orientado a objetos se enfoca a las características de comportamiento y estructura de las entidades como unidades completas, lo que nos permite diseñar software de manera modular y con un alto manejo de estructuras de datos complejas. El paradigma orientado a objetos se apoya en los siguientes conceptos: • La Abstracción (de datos) involucra la formulación de un concepto (clase) poniendo

atención en las similitudes y diferencias entre las entidades de un conjunto, para extraer las características esenciales que lo distingan y evitar las características no relevantes. Y así, se establece una sola representación del concepto que tenga esas características pertinentes.

Es la capacidad de crear tipos de datos definidos por el usuario extrayendo las propiedades esenciales de un concepto, sin preocuparse de los detalles exactos de la implementación. Algunos simplemente lo definen como la capacidad de enfocarse en lo esencial.

• La Encapsulación asegura que los usuarios de un objeto no alteren de manera

inesperada el estado interno de un objeto; solo sus métodos internos están autorizados para acceder a ellos. Cada objeto expone una interfaz publica que especifica como otros objetos podrían interactuar con él.

La abstracción y la encapsulación están representadas por la clase. La clase es una abstracción, porque define los atributos y métodos de un determinado conjunto de objetos con características comunes, y es una encapsulación por que constituye una caja negra que encierra tanto los datos que almacena como los métodos que permiten manipularlos.


3

• La Herencia Es la capacidad de definir una nueva clase a partir de otra clase. De esta

forma, la reutilización del código esta garantizada. Las clases están clasificadas en una jerarquía estricta, donde la clase padre es conocida como superclase y la clase hijo como clase derivada. Esto significa que la clase derivada dispone de todos los atributos y métodos de su superclase.

• El Polimorfismo es la propiedad que permite a una operación tener diferente

comportamiento en diferentes objetos. Es decir, diferentes objetos reaccionan de manera diferente al mismo mensaje (de modo que un mismo método pueda tener múltiples implementaciones).

Estos conceptos son los pilares de la POO que permiten facilitar la comunicación, incrementar la productividad y la consistencia, facilitar la modificación de los programas y reducir la complejidad en esfuerzos de resolución de problemas.

1.1.2 Los Inicios del Lenguaje Java Java es uno de los lenguajes de programación orientado a objetos mas versátil e interesante de finales del siglo XX (1994), detrás de él existe una inherente similitud con la sintaxis de C++, debido quizás a una estrategia de mercado ya que resultaba como una especie de colonización de C++ a Java. El lenguaje de programación Java se origino como parte de un proyecto de investigación para el desarrollo de un lenguaje de programación llamado “Oak” (1992), que buscaba superar la barrera de comunicación entre varios dispositivos, como video caseteras y televisores. En la compañía Sun, existía un grupo de desarrolladores de software muy hábiles a los que se les conocía con el nombre de “Green team” encabezados por James Arthur Gosling (Figura 5), este grupo de desarrolladores trabajaban en la construcción de un lenguaje de programación que fuera capaz de compartir el mismo software en diferentes unidades centrales de procesamiento. Este concepto inicial fallo después de varios intentos, pues las compañías diseñadoras de dispositivos fueron incapaces de vislumbrar los beneficios y el nicho de mercado que se presentaba, por lo que el “Green team” fue forzado a encontrar otro mercado para su nuevo lenguaje de programación. Afortunadamente, en ese lapso de tiempo Internet comenzó a ser mas popular y accesible (1994) y el “Green team” pudo estar consciente que el lenguaje Oak era perfecto para el desarrollo Web de componentes multimedia para la construcción de paginas Web. Estas pequeñas aplicaciones, llamadas applets, llegaron a ser el primer contacto del lenguaje para los programadores de Internet. De esta manera Java se convirtió rápidamente en un lenguaje poderoso y versátil, ya que incluía una variedad de cualidades que lo hacia idóneo para el desarrollo Web, debido principalmente a que contaba con una plataforma de desarrollo y un esquema de ejecución (maquina virtual) que permitía la portabilidad del sistema en casi cualquier arquitectura computacional que lo implementara. Además de una interfaz gráfica muy simple y eficiente, además de altamente portable. En la actualidad el lenguaje cuenta con las siguientes características:


4

• Orientación a objetos • Esquema distribuido • Esquema de programación paralelo (multithreads) • Esquema de seguridad en ejecución y transacciones • Plataforma independiente (JVM)

Figura 5: James Gosling

1.2 El Entorno de Desarrollo de Java

1.2.1 Modelo de programación El modelo de programación es el conjunto de gramáticas y reglas semánticas formales que describan rigurosamente el significado de un programa en términos de las abstracciones que lo caracterizan. En el lenguaje Java el modelo de programación es concretamente orientado a objetos, es decir, la estructura básica de programación es la clase por lo que cualquier programa en Java es única y exclusivamente una clase.

class Nombre-Clase {

public static void main (String [] args){

// Cuerpo de programa

}

} En Java se elimina el uso de apuntadores que pueden afectar la estabilidad del código, en tal caso existe únicamente un conjunto de datos nativos y un sin número de objetos, a los que llamaremos datos referenciados o simplemente referencias (objetos). Además del modelo orientado a objetos Java soporta el modelo de programación distribuida que nos permite utilizar dos o mas computadoras (colección de computadoras heterogéneas) que se comunican a lo largo de una red para ejecutar una tarea en común.


5

1.2.2 Arquitectura de la Tecnología Java

Java es un lenguaje de programación muy peculiar pues se cataloga como compilador-interprete, pues es capaz de generar un tipo especifico de código intermedio que es fácilmente transportable a casi cualquier plataforma computacional esto se debe a que la tecnología de java se sustenta en 3 mecanismos principales que como veremos a continuación le permiten adquirir todos los beneficios de un sistema multiplataforma: • Compilador Java: el compilador de java interpreta el código y genera un código

intermedio denominado bytecode que puede ser fácilmente reinterpretado por una maquina virtual java.

• JRE: el ambiente en tiempo de ejecución es el software responsable de permitir al usuario final ejecutar las aplicaciones java, posee una colección o librería estándar de clases que son indispensables para el funcionamiento de los programas java, además de incluir una maquina virtual para el lenguaje java.

• Java VM: La maquina virtual de java (JVM) provee una especificación de plataforma la

cual le permite ejecutar cualquier programa compilado en java (bytecode). De esta forma el compilador de java toma cualquier código hecho en java y genera un archivo precompilado llamado bytecode que es un conjunto de instrucciones que puede ser interpretado por cualquier maquina virtual de java.

A continuación se muestra el esquema en tiempo de ejecución de la tecnología java y como interactúan sus diversos elementos:


6

El código fuente (Ejemplo.java) es compilado y se genera un archivo convertido a bytecode (Ejemplo.class), éste es el archivo que será cargado y ejecutado en alguna maquina objeto. Al tiempo de ejecución, el código en bytecode es leído, verificado y puesto para su ejecución en el intérprete. El interprete tiene dos funciones ejecutar bytecodes y hacer las llamadas apropiadas al hardware. En algunos ambientes de ejecución una porción de la verificación de bytecode es compilada en código nativo de maquina y ejecutado directamente en la plataforma de hardware, por lo que la velocidad de interpretación-ejecución se acelera. Ahora si se trata de un lenguaje dinámico que crea y destruye objetos en tiempo de ejecución, ¿qué mecanismo se encarga de liberar las instancias construidas en memoria de los diversos objetos? Muchos lenguajes de programación permiten alojar memoria de manera dinámica en tiempo de ejecución. El proceso para alojar memoria varía de acuerdo a las características del lenguaje y en ciertas ocasiones los bloques de memoria reservados nunca son liberados, principalmente porque esta tarea se deja a cargo del programador (como en C/C++). Java provee un mecanismo de recolección de bloques de memoria inútiles y los remueve de manera automática. Durante la ejecución de los programas en la maquina virtual, el recolector de basura (Garbage Collection) comienza a verificar si existen bloques de memoria (objetos) que han dejado de ser usados o referenciados de tal manera que los marca para que en el próximo ciclo de verificación sean eliminados y se recupere espacio de memoria.

Compilación Ejecución

Ejemplo.java

javac

Ejemplo.class

Se lee el programa de disco, red u otro medio

java clase Loader

verificador Bytecode

Interprete

Ejecución

Hardware

generador de código JIT


7

1.2.3 El Compilador e Interprete de Java El lenguaje de programación java requiere de una infraestructura necesaria para su desarrollo y ejecución, inicialmente veremos cómo están constituidas sus plataformas de ejecución y desarrollo, posteriormente mencionaremos algunas aplicaciones que se pueden emplear como ambiente ambientes de desarrollo para facilitar la programación de aplicaciones. JRE (Java Runtime Environment) Es un paquete que contiene todo el software necesario para correr una aplicación desarrollada en Java, dentro del paquete esta contenida la librería de clases, que son programas generados en java (bytecode) y que están expresamente construidos para servir de apoyo para la construcción de aplicaciones por parte del usuario, además se cuenta con: • Librerías de integración que permiten construir aplicaciones de comunicación externa. • Librerías de interfase grafica de usuario AWT/Swing. • Librerías para el manejo de multimedia. • Una maquina virtual de java adecuada a la plataforma que permite ejecutar las

aplicaciones. JDK 2 (Java Distribution Kit 2) Es el conjunto de herramientas para el desarrollo de aplicaciones en Java, esta compuesto por las siguientes herramientas de programación: • javac – Compilador de java que se encarga de convertir código fuente a bytecode de

java. • jar – Programa que se encarga de manipular librerías de clases ya compiladas y

empaquetadas. • javadoc – Programa que se encarga de extraer documentación automáticamente

partiendo de los comentarios en el código fuente. • jdb – Depurador de programas. Además de las herramientas adicionales para desarrolladores, se agrega el paquete JRE que contiene todas las librerías de clase y la maquina virtual en la que se producirán y ejecutaran las aplicaciones. Las herramientas de desarrollo esta disponible en 3 posibles versiones:

• Edición Micro: Se emplea en ambientes con recursos limitados. • Edición Estándar: Es la edición comúnmente empleada por la mayoría de los

programadores. • Edición Empresarial: Es una edición que posee una colección muy amplia de

recursos adicionales para transacciones en Internet, seguridad y acceso a recursos remotos.

1.2.4 Ambientes de Desarrollo Integral para Java Los ambientes de desarrollo son aplicaciones que nos permiten escribir en un lenguaje de programación de manera sencilla, ya que se puede verificar gradualmente el producto que estemos desarrollando. De esta forma el ambiente de desarrollo se encuentra totalmente


8

independiente de la plataforma de Java que se emplee, es decir que se puede emplear cualquier versión del kit de desarrollo de software (JSDK) de Sun. Existen varios ambientes de desarrollo en el mercado, los hay desde los libres que no tienen algún costo, hasta las herramientas mas sofisticadas y caras del mercado. El lenguaje Java (plataforma Java) y el ambiente de desarrollo integral no son una sola aplicación, en tal caso deberán ser instaladas de manera independiente. Se recomienda inicialmente instalar la plataforma de Java (JSDK) y posteriormente el ambiente de desarrollo que mas se ajuste a sus necesidades. En la red existen disponibles varios ambientes para el desarrollo de software como:

o NetBeans: una herramienta creada por una filial de Sun Microsystems, es una buena herramienta de diseño aunque algo lenta si se cuenta con poca memoria principal. Permite el diseño RAID (diseño rápido de interfase).

o Eclipse: una herramienta de distribución libre bastante flexible en uso de recursos y fácil de emplear debido a su poca complejidad, permite la opción de auto-completar texto.

o Notepad++: es una herramienta amigable y fácil de emplear, cuenta con una versión libre bastante austera y simple de integrar para los lenguajes más comunes además de Java.

Es importante recordar que en el mercado se encuentran disponibles varias distribuciones libres para ambientes de desarrollo integral en Java, así que se deja al criterio del alumno el uso de cualquiera de ellas. También se encuentra disponible una plataforma de diseño integral para Java, conocida como Eclipse, desarrollada por IBM. Eclipse es algo mas que un simple ambiente de desarrollo integral (JDT), ya que cuenta con su propio kit de desarrollo para compilación (ECJ). Desde un principio se considero a Eclipse como una distribución libre para Java, por lo que su popularidad no se ha disminuido ante su más claro competidor Sun Microsystems. Desafortunadamente por cuestiones de licencias Eclipse requiere la instalación de JRE para mantener la portabilidad.

1.3 Fundamentos del Lenguaje Java Cuando hablamos de lenguajes de programación debemos tomar en cuenta ciertas convenciones y consideraciones relativas a la manera en que trabaja el lenguaje de programación, así como observar los elementos de lenguaje más básicos que nos permiten entender el mecanismo de programación y los elementos del lenguaje.

1.3.1 Convenciones de escritura La sintaxis del lenguaje nos describe la manera en como deben ser estructurados los programas escritos en el lenguaje de programación para que sean considerados como entidades validas, a continuación describiremos algunas convenciones básicas para la escritura de programas Java. Es importante recordar que los nombres de los identificadores en Java son sensibles a las letras mayúsculas y minúsculas. Para facilitar la lectura y mantenimiento de nuestros programas aplicaremos las siguientes normas:


9

• Cuando un nombre consta de varias palabras, se escribirá una a continuación de otra, poniendo con mayúscula la primera letra de cada palabra que sigue a otra (ejemplos: elMayor(), RectanguloGrafico).

• Los nombres de clases comenzarán siempre por mayúscula (ejemplos:

RectanguloGrafico, Vector).

• Los nombres de las interfaces comenzarán con la letra ‘I’.

• Los nombres de los paquetes comenzarán con las letras “pack”.

• Los nombres de objetos, métodos, variables miembro y variables locales comenzarán siempre por minúscula (ejemplos: dibujar(), numRectangulos, x).

• Los nombres de las variables finales, es decir de las constantes, se definirán en

mayúsculas (ejemplo: PI, MAXIMO).

• Los nombres de los parámetros de los métodos empezarán por la letra ‘p’ (ejemplos: pValor1, pResultado)

1.3.2 Palabras reservadas Las palabras claves tienen un significado especial para el compilador de Java, ya que identifican el nombre de un tipo de dato o una construcción de programa. Es decir son el conjunto de primitivas que forman al lenguaje de programación, además de la estructura gramatical que forma el lenguaje de programación. A continuación se muestra el conjunto de primitivas del lenguaje Java: abstract continue for new switch assert default goto package synchronized bolean do if private this break double implements protected throw byte else import public throws base enum instanceof return transient match extends int short try char final interface static void class finally long strictfp volatile const float native super while Las siguientes son notas importantes acerca de las palabras claves: • Las literales true, false y null se escriben en minúsculas, estrictamente hablando no

son palabras claves. • No existe el operador sizeof que nos permita acceder a la memoria, pero se cuanta

con otro operador mas potente que nos permite manipular objetos propiamente. • Las palabras claves goto y const no son usadas en el lenguaje Java.


10

Comentarios Los comentarios de documentación se colocan inmediatamente antes de una declaración (de variables, métodos o clases) indicando que los comentarios deben ser incluidos en alguna documentación que es generada de manera automática (por ejemplo, los archivos HTML generados por el comando javadoc) para servir como descripción de los elementos declarados. Existe el comentario en una sola línea tipo C: // comentario. Y existe la documentación en bloque, que abarca un mayor numero de líneas, que comprende desde el inicio de bloque (/*) hasta el final del mismo (*/). /* Inicio de comentario y el final del comentario */

Bloques de código En el lenguaje de programación java un estatuto es una o más líneas de código que terminan con punto y coma (;), por ejemplo: total = a + b +c + d; ó también total = a + b + c + d; Un bloque, algunas veces llamado estatuto compuesto, es un grupo de estatutos encerrados entre llaves de apertura y cierre ({}). Un bloque es útil cuando se requiere agrupar estatutos. {

// un bloque de estatutos x = y +1; y = x +1; } while ( i < long ) { // un bloque de estatutos puede estar

a = a + i; // contenido en otro bloque If ( a == max ) { // y en otro bloque b = b + a; a = 0; }

i = i + 1; }

Elemento basico de programación En el lenguaje de programación java solo es posible construir clases, por lo que la unidad mínima de programación es la clase. Dentro de la definición de una clase únicamente puede existir una sola función main, que sera la responsable del inicio y fin de la ejecución del programa, y a su alrededor se encontraran todas las demás clases que formen parte del programa:


11

class NombreClase { public static void main( String [] args ) { System.out.println(" Hola mundo !!! "); // mensaje de salida } }

1.3.3 Tipos de datos, Variables y Operadores El lenguaje de programación Java cuenta con varios tipos de datos. Estos caen en dos grandes categorías:

1. Datos Primitivos: Son aquellos tipos de datos que se encuentran inmersos en el lenguaje y cuentan con un espacio fijo para su valor.

2. Datos Referenciados: En este grupo se encuentran los arreglos y los objetos de

cualquier tipo de clase que se tenga disponible en el API o que se construya por el programador.

Los tipos primitivos son valores simples, no son objetos, de manera que se trata del tipo de dato mas simple el cual puede ser claramente identificado y existe en un lugar específico de la memoria. Los tipos referenciados u objetos de una clase son tipos de datos compuestos.

Ø Tipos de Datos Primitivos El lenguaje Java define ocho tipos primitivos, los cuales pueden ser considerados en cuatro categorías:

o Lógicos – boolean o Texto – char o Enteros – byte, short, int y long o Punto flotante – float y double

ü Lógicos Los valores lógicos son representados usando los tipos boléanos, los cuales toman uno de dos posibles valores literales: true (verdadero) ó false (falso). A continuación se muestra un código de ejemplo que declara e inicializa una variable de tipo boolean. boolean verdad = true; No existe ajuste (cast) entre valores de tipo entero y boléanos, como ocurre en otros lenguajes de programación como C/C++. Solo pueden usarse cualquiera de las dos literales definidas. ü Texto Los caracteres simples son representados usando el tipo char. Un char representa un carácter de 16-bits en UNICODE. Los caracteres deben ser indicados como literales encerrados en comilla simple (‘ ‘), por ejemplo:


12

‘a’ La letra a

‘\t’ una tabulación

‘\u????’ Un carácter especifico UNICODE, las interrogaciones (????) son reemplazadas con exactamente cuatro dígitos hexadecimales. Por ejemplo ‘\u03A6’ es Φ (phi)

Ahora mostramos un ejemplo de declaración e inicialización de una variable tipo carácter. char ch = ‘A’; ü Enteros Existen cuatro tipos enteros en Java. Cada tipo es declarado usando una de sus palabras claves, byte, short, int ó long. Se pueden crear literales de tipos enteros usando la forma decimal, octal hexadecimal.

2 Forma decimal del numero 2 077 0 indica un número octal 0xBAAC 0x indica un número hexadecimal

Todas las literales enteras son de tipo int a no ser que se especifique lo contrario, es decir se puede agregar al final de la literal numérica la letra L, que indica que el valor será entero largo. A continuación se presenta una tabla con el tamaño y rango que representan los números:

Longitud Tipo Rango 8 bits byte de -27 a 27-1 16 bits short de -215 a 215-1 32 bits int de -231 a 231-1 64 bits long de -263 a 263-1

ü Punto flotante Los tipos flotantes pueden declararse como float o double. A continuación veremos algunos ejemplos de numero flotantes. Las literales flotantes pueden incluir el punto decimal o el termino exponente (E), además de las letras F para float y D para double. Los números flotantes en Java ocupan 32 bits, mientras que los valores dobles ocupan 64 bits.

3.14 valor simple flotante (double) 6.02E23 valor de punto flotante largo 2.718F valor de punto flotante simple 123.4E+306D valor doble flotante


13

Variables, declaración y asignación Las variables son los identificadores construidos para asignar valores que serán manipulados a lo largo del programa. Las declaraciones de variables deben seguir la siguiente sintaxis:

<tipo de dato> identificador [ = valor ] ; Las asignaciones siempre deben de corresponder al tipo de datos que se está manejando, existen errores comunes de asignación, como son:

int y = 3.1415926; double w = 175,000; boolean sw = 1; float z = 3.14156;

Los identificadores comienzan con letra, guión bajo ó signo de dólar, y el resto de los caracteres pueden ser dígitos. Recuerde que los identificadores son casos sensitivos. Debido a que pueden emplearse caracteres no ASCII, tenga presente lo siguiente: • UNICODE puede soportar diferentes caracteres que lucen igual. • Los nombres de clase deben ser únicamente caracteres ASCII, debido a que la

mayoría de sistemas no soportan UNICODE. • Un identificador no puede ser una palabra clave, pero puede estar compuesta como

parte del nombre. El siguiente es un programa que muestra como declarar variables de distinto tipo de dato primitivo y como es posible emplear el operador de suma para concatenarlo con una salida de datos, tome en cuenta que al realizar una operación dentro de una llamada a print deberá emplear los paréntesis para hacer hincapié en la operación aritmética. public class Main { public static void main( String [] args ) { // delcaracion de variables locales String mensaje = "Hola"; double a = 13.2345; int b = 12; System.out.println(mensaje + " mundo !!! "); System.out.print("el total de " + a + " + " + b); System.out.print(" es " + (a+b)); } }

Ajuste de datos primitivos El ajuste primitivo o cast, significa asignar el valor de un tipo de variable a una de otro tipo. Si dos tipos son compatibles, Java realiza el ajuste automáticamente. Por ejemplo un valor tipo int puede ser asignado sin ningún problema a una variable tipo long (promoción).


14

En los casos donde la información se pueda perder en la asignación, el compilador requiere que se le confirme la asignación a través del operador cast. Por ejemplo:

long big = 99l; int medium = big // asignación invalida int medium = (int) big // cast aplicado

Es necesario que el tipo de dato destino sea encerrado entre paréntesis y usado de manera prefija indicando que la expresión debe ser modificada. Las variables pueden ser promocionadas automáticamente a tipos más grandes (como de int a long)

double x = 12.414F; // 12.414F es flotante, correcto float y = 12.414; // 12.414 es doble, incorrecto

Cuando se realizan operaciones como la suma y los dos operándoos son de tipo de dato primitivo, el tipo de dato resultante es determinado por el operando de tipo más grande, por lo que en algunos casos podría ser un problema de sobre flujo, por ejemplo:

short a, b, c; a = 1; b = 2; c = a + b;

Causa un error debido a que los tipos short involucrados en la operación elevan las funciones al tipo int por lo que se vuelve indispensable un ajuste, a no ser que la variable c sea declarada como int, para subsanar este problema se sugiere realizar un cast en la operación que permita el ajuste.

c = (short) (a + b);

Constantes Java emplea la palabra clave final para indicarle al compilador de que las variables declaradas bajo esta etiqueta deberán comportarse como si fueran constantes. Esto indica que su valor no puede ser modificado una vez que se haya declarado e inicializado. Las constantes se declaran de la siguiente manera: final double PI = 3.14159; final char VALOR = ´S´; final String MENSAJE = “Error”; Si se intenta cambiar el valor de las variables tipo final desde una aplicación, se genera un error de compilación. Es importante recordar, como medida de diseño, que los nombres de las constantes deben escribirse con letras mayúsculas para facilitar su ubicación dentro del código. También los las funciones miembro (métodos) pueden ser de tipo final, en cuyo caso no podrán ser sobrecargados.


15

Ø Tipos de Datos Referenciados Es aquel tipo de dato que almacena una dirección de memoria donde aloja la referencia a un bloque de memoria asignado de manera dinámica. Aquí podemos encontrar varias clases que ya se encuentran implementados dentro del API de Java, pero inicialmente podríamos proporcionar una clasificación burda de la siguiente manera:

o Arreglo – <tipo> [ ] <identificador> o Cadena de caracteres – String o Wrappers – Character, Byte, Short, Integer, ... o Definidas por usuario – class <Identificador> { }

o Tipo de dato Arreglo Los arreglos son estructuras de datos que agrupan elementos del mismo tipo (homogéneo). Los arreglos nos permiten referirnos a grupos de objetos por un nombre común. Los arreglos unidimensionales, son arreglos que cuentan únicamente con una fila y con una serie de columnas que determinan la dimensión del arreglo. En Java es posible crear arreglos de cualquier tipo, ya sea datos primitivos o definido por el usuario (objetos).

Declaración de arreglos unidimensionales La sintaxis es la siguiente:

<tipo> [ ] <nombre-arreglo>; Cuando queremos que una variable sea un arreglo únicamente anteponemos los corchetes, esto le indica al compilador que la variable de la derecha será una referencia de arreglo. En el lenguaje Java un arreglo es un objeto aún cuando el arreglo sea de tipos de datos primitivos, además como el resto de los objetos, la declaración no crea el objeto por si mismo. En su lugar la declaración de un arreglo crea una referencia que puede ser empleada para un arreglo. El espacio en memoria usado para los elementos del arreglo, es dinámico, por lo que es necesario emplear el operador new para crear el espacio para los elementos del arreglo.

Creación de referencias para arreglos Se deben crear arreglos como objetos, empleando el operador new, por ejemplo, suponga la creación de un arreglo de caracteres (primitivo).

char[] s; s = new char[26]; for ( int i=0; i<26; i++ ) { s[i] = (char) ('A' + i); } El operador new crea un arreglo con 26 caracteres que serán inicializados cada uno de sus elementos a carácter vació (‘\u0000’). De esta forma el arreglo esta listo para ser manipulado. Recuerde que el límite de los arreglos va de 0 a N-1.


16

Debe tomar en cuenta que todo objeto referenciado en java es por defecto un objeto de la clase Object, la clase Object es la clase más alta en la jerarquía de objetos referenciados y más adelante veremos que tiene varios métodos y propiedades asociadas a él y que son transferidas al resto de los objetos referenciados por medio de un esquema de herencia. Observe como el objeto char [] s, es inicializado mediante el operador new, que es el responsable de asignar un bloque de memoria temporal a todos los objetos referenciados. Ahora debemos percatarnos que siendo un tipo de dato referenciado, como tal, tendrá propiedades como por ejemplo el número de elementos inicializados en él (length) que será su longitud. public class ArrayChar { public static void main( String args [] ){ char[] s; int dim = 26; s = new char[ dim ]; for ( int i=0; i < 26; i++ ) { s[i] = (char) ('A' + i); } System.out.print("El abecedario es "); for ( int i=0; i < s.length; i++ ) System.out.print(s[i]); System.exit(0); } }

Inicialización de arreglos Cuando se crea un arreglo, cada elemento es inicializado. Para el caso del arreglo de caracteres vimos que cada carácter es inicializado por defecto a (‘\u0000’) lo que indica que aún no ha sido ingresado ningún dato dentro de la casilla. Además es posible crear inicializaciones de manera corta como la siguiente:

char [] vocales = { 'a', 'e', 'i', 'o', 'u'}; O también de manera equivalente:

char [] vocales; vocales = new char [ 5 ]; vocales [0] = 'a'; vocales [1] = 'e';

Arreglos multidimensionales Java provee un mecanismo muy eficiente y sencillo para la construcción de arreglos multidimensionales, solo es necesario indicar el numero de dimensiones con las que se desea trabajar, es decir, así como con los vectores, solo es necesario agregar una dimensión usando los corchetes.


17

Podemos crear arreglos multidimensionales de la siguiente manera:

int [ ][ ] matriz = new int [2][ ]; matriz[0] = new int [5]; matriz[1] = new int [3]; matriz[2] = new int [3]; /*** error fuera de índice ***/

El objeto que es creado en la primera llamada con new es un arreglo que contiene dos elementos. Cada elemento es una referencia nula (null) a un elemento de tipo array of int, y debe ser inicializada cada elemento de manera separada, de manera que cada elemento apunta a su arreglo. Debido a esto es posible crear matrices no-rectangulares. En algunos casos esta inicialización podría parecer tediosa, pues es más común emplear matrices rectangulares, a continuación vemos como sería la declaración e inicialización de una matriz de enteros:

int [ ][ ] matriz = new int [4][5]; Veamos ahora un ejemplo de una matriz de valores dobles a la que se le asignan valores de manera aleatoria empleando una función estática llamado random() perteneciente a la clase Math, veremos más adelante que al igual que System.out, Math no requiere construir una instancia de la misma para ser usada: public class MatrizRand { public static void main( String args [] ) { int f = 5, c = 2; double m[][] = new double [f][c]; System.out.print("numero de filas " + f); System.out.print("numero de columnas " + c); for ( int i = 0; i < m.length; i++ ) { for ( int j = 0; j < m[i].length; j++ ) m[i][j]= Math.random(); } for ( int i=0; i < m.length; i++ ) { for ( int j=0; j < m[i].length; j++ ) System.out.print(" ("+ i +"," + j + ") -> "

+ m[i][j]); System.out.println(); } System.exit(0); } } Como ya se menciono los arreglos en java son objetos, por lo que el número de elementos que pueden ser almacenados forma parte de sus atributos. Un acceso a un límite fuera de su longitud produce un error en tiempo de ejecución (out of index). Se recomienda ampliamente emplear el atributo length para iterar dentro de un arreglo.


18

Re-dimensión de arreglos Después de que ha sido creado un arreglo, no puede ser redimensionado su tamaño. Sin embargo puede ser empleada la misma referencia a la variable para declarar una nueva referencia del arreglos por completo.

int [] arreglo = new int [6]; arreglo = new int [10];

En este caso, el primer arreglo pierde la referencia a todos sus componentes, a no ser que sean almacenados en algún lugar previo a la nueva redefinición del nuevo bloque de memoria dinámico.

o Tipo de dato String Existen, además de los arreglos, otro tipo de dato referenciado, la Clase String (o simplemente String) los objetos de la clase String tienen la peculiaridad de almacenar la referencia a una literal alfanumerica. Como objeto los Strings tienen una colección de métodos que les provén de una mayor funcionalidad con otros objetos. La clase String es una de tantas clases incluidas en la librería de clases de Java (API). La clase String provee la habilidad de almacenar secuencias de caracteres y números, y manipularlos de forma sencilla. Los objetos String pueden ser declarados de cinco maneras:

ü String nombre = “Juan Pérez”;

ü String nombre = new String();

String nombre = “”; // equivalente

ü String s = “Juan Pérez”; String nombre = new String(s); String nombre = new String(“Juan Pérez”); // equivalente

ü char [] s = {’a’,’e’,’i’,’o’,’u’}; String nombre = new String(s);

ü char [] s = {’a’,’e’,’i’,’o’,’u’}; String nombre = new String(s, 1, 3); // eio

La clase String es la única que permite construir objetos de ese tipo sin emplear el operador new, que es el empleado para crear cualquier referencia (objeto) en Java. Como hemos visto las referencias u objetos adquieren propiedades directas de una clase superior llamada Object, para el caso de los datos referenciados como el String se tiene el metodo length() que nos indica el numero de caracteres contenidos en un String. Pero es importante recordar que dicha clase define muchas mas funciones que pueden resultar muy útil para el manejo de cadenas. A continuación se comentan algunas de ellas, pero es importante recordar que se cuentan con muchas más. A continuación asuma que s1 y s2 son objetos de tipo String:


19

public class Prueba { public static void main(String [] args) { String s1 = "hola"; String s2 = new String("mundo"); if ( s1.equals(s2) ) System.out.println("iguales"); else System.out.println("diferentes"); s1 = s1.toUpperCase(); s2 = s1.concat(s2); String s3 = s2 + "bizarro".toUpperCase(); System.out.println(s3); } } o s1.equals(s2), regresa verdadero (true) en caso de que los caracteres de s2

correspondan exactamente con los de s1. o s1.toUppercase(), regresa un objeto de tipo String con exactamente cada carácter

de s1 en mayúscula. o s1.charAt(n), regresa como valor el n-ésimo carácter en un String public class Prueba { public static void main(String [] args) { String s1 = "un buen saludo hola, como estas!"; String s2 = "hola"; int inicio = s1.indexOf(s2); int fin = inicio + s2.length(); String s3 = s1.substring(inicio,fin); System.out.println(s3); } } Recuerde también que los objetos de tipo String pueden ser fácilmente concatenados empleando el operador de +, por ejemplo: String s1 = "Hola"; String s2 = "mundo"; String s3 = s1 + " " + s2; Inclusive el objeto estático System.out.print() puede concatenar una serie de valores sin importar el tipo, por ejemplo:

int edad = 23; System.out.println("Hola mi edad es " + edad);

En realidad el objeto String es el único objeto en java que cuenta con las características de concatenación empleando el operador de + (suma) y asignación directa empleando el operador =. Desafortunadamente son los únicos operadores en java que tienen ese comportamiento, además de los wrappers, es importante recordar que la sobrecarga de


20

operadores no se encuentra disponible en el lenguaje como tal, por lo que no es posible implementarla, como es el caso de C++ o C#. Para el programador dedicado a la construcción de aplicaciones finales que tiene una gran necesidad de manejar nombres e incluso cambios de valores entre tipos reconocerá en este lenguaje muchos beneficios que no son tan palpables en otros lenguajes de programación. public class ArrayOfString { public static void main( String args [] ) { String [] nombres = {"Moira", "Paula", "Seth"}; System.out.println("tamaño del arreglo " + nombres.length + '\n'); for (int i = 0; i < nombres.length; i++) System.out.println("nombre " + nombres[i] +

" tiene " + nombres[i].length() + " caracteres"); System.exit(0); } } También es posible construir arreglos de tipo String, solo debe de recordar que para este caso existen 2 mecanismos para obtener la longitud, una la del arreglo length (propiedad) y otro la longitud total de caracteres por cada elemento length().

o Clases Envoltorio (Wrappers) Las clases envoltorio (Wrappers) son clases que proveen un mecanismo para interactuar con algún otro tipo de dato abstracto. Para el caso de los tipos de datos primitivos, las clases envoltorio son un mecanismo más refinado de programación para representar valores primitivos cuando un Objeto es requerido. Java provee ocho tipos de clases envueltas para datos primitivos:

Tipo primitivo Clase envoltorio Argumentos del constructor byte Byte byte o String short Short short o String int Integer int o String long Long long o String float Float float, double o String double Double double o String char Character char boolean Boolean boolean o String

Las clases Wrapper de primitivas numéricas se derivan de la clase Number que deriva de Object. Cada una de estas clases contiene un valor primitivo del tipo relacionado, por ejemplo un objeto Integer contiene un valor int como atributo. De manera que estas clases envoltorio (Wrappers) no son más que clases que modelan los tipos de datos primitivos tales como enteros ó flotantes, precisamente estos tipos primitivos son los únicos elementos en Java que no son clases. Estos Wrappers nos permiten introducir algunos conceptos interesantes de programación, como por ejemplo el autoboxing que consiste en convertir un tipo de dato primitivo a un tipo compuesto,


21

aunque también es posible realizar el proceso inverso, el automatic unboxing que trata de convertir un objeto compuesto a un valor primitivo. Este tipo de conversión es generalmente transparente al usuario:

• autoboxing, los valores enteros son empacados automáticamente en un tipo Integer empleando el operador de asignación.

Integer i, j; // objetos i = 5; // al objeto i se le asigna un valor nativo j = 4;

• unboxing, los valores son desempacados automáticamente del tipo Integer al tipo nativo int para ser procesados y finalmente se asigna a un tipo nativo int.

int r = i + j; Existe una diferencia significativa entre los tipos primitivos y sus Wrapper; ya que los tipos primitivos pasan como argumento por valor a los métodos, mientras que los objetos pasan por referencia. Esto implica una ventaja en cuanto a eficiencia, pues es posible modificar el valor de una referencia tipo Wrapper. Por otro lado las referencias Wrapper ofrecen funcionalidad con varios métodos estáticos de manera que es posible usarlos sin necesidad de crear un objeto. Por ejemplo la clase Integer cuenta con un método denominado parseInt que permite convertir una cadena de caracteres alfanumérica a un valor de una base en particular:

String s = "0001101"; int x = Integer.parseInt(s,2); // x conserva el valor 13

Casi todos estos métodos pueden utilizarse en forma estática, de manera que, no siempre sea necesario crear una instancia para manipularlos. Por ejemplo:

int i; i = Float.valueOf(12.45).intValue();

Como se habrá observado no existe una librería del tipo ctype de ANSI/C que nos permita manipular caracteres de manera independiente, para ello se emplea la clase Character que cuenta con varios métodos que permite manipular caracteres simples. Por ejemplo: String s = "Madero 122";

char [] name = s.toCharArray(); for (int index = 0; index < name.length ; index++) if ( Character.isDigit(name[index]) )

System.out.println("digito " + name[index]); else if (Character.isLetter(name[index]))

System.out.println("letra " + name[index]); También es posible crear arreglos de objetos Wrapper, de manera que cada elemento del arreglo corresponderá a un objeto particular:


22

Double [] arreglo = {2.3,4.5}; Integer [][] matriz;

El siguiente ejemplo construye un arreglo de caracteres a partir de un objeto String, una vez transformado puede ser manipuladode forma mas simple por su operador de indice “[ ]”. De esta forma el Wraper de Caracters es usado para invertir las mayusculas a minuscular y viceversa. public class Main { public static void main(String args[]) { int cont = 0; String frase = "Esto es una cadena"; char [] array = frase.toCharArray(); //regresa un arreglo char for (int i = 0; i < array.length; i++) { if (Character.isLetter(array[i])) array[i] = Character.isLowerCase(array[i]) ? Character.toUpperCase(array[i]):Character.toLowerCase(array[i]); if (Character.isDigit(array[i])) cont++; } frase = String.valueOf(array); //regres el arreglo a String System.out.print(frase + cont); } }

Operadores Lógicos, Relacionales y Aritméticos Los operadores son elementos del lenguaje que nos permiten construir expresiones, dichas expresiones las podemos dividir básicamente en: lógicas, relacionales y aritméticas. A continuación se explicaran por grupo los operadores disponibles en Java. Operadores Lógicos – los operadores lógicos evalúan expresiones para obtener un resultado boolean, que puede ser cierto (true) o falso (false). Los operadores boléanos soportados son !, &, ^ y | para las operaciones algebraicas de NOT, AND, XOR y OR, respectivamente. Cada una de estas regresa un resultado booleano. Los operadores && y || son equivalentes a los operadores & y |. Operadores Relacionales – también existen los operadores ==, !=, >, >=, <, <= para las operaciones de igualdad, diferente, mayor, mayor igual, menor, menor igual, respectivamente. Operadores Aritméticos – Java emplea exactamente los mismos operadores aritméticos que el lenguaje C/C++, como +, -, * / y % para las operaciones de suma, resta, multiplicación, división y modulo, respectivamente. Además existen los operadores combinados como el incremento y decremento unitario ++ y --. Y combinaciones de asignación con operación aritmética, como *=, +=, /=, %=, y que nos permiten realizar operaciones sintetizadas como X = X + Y en X += Y.


23

Como algo adicional Java implementa el operador condicional idéntico al de C/C++:

<expresión_boolean>?<expresion1>:<expresion2> Por ejemplo, si el valor lógico de una comparación es cierta la primera expresión será almacenada, en caso contrario la expresión 2 será asignada:

int x = (5 == 3) ? 1 : 0;

Precedencia de operadores A continuación se presenta una lista de los operadores descritos con anterioridad, en el listado se presentan dichos operadores ordenados de mayor precedencia a menor precedencia:

Operación Símbolo operadores unarios multiplicación y división: suma y resta: operadores relacionales: igualdad y desigualdad: conjunción: disyunción: operador condicional: operadores de asignación:

++, --, !, - +, type-cast *, /, % +, - <, >, <=, >= ==, != && || ?: =, +=, -=, *=, /=, %=

Los operadores aritméticos siguen las mismas reglas de precedencia que el resto de los lenguajes que son: la multiplicación y división, modulo, suma y resta. Para los operadores relacionales y lógicos la interpretación de evaluación es de izquierda a derecha.

1.4 Unidad Minima de Programación En Java la clase es la estructura primordial para el diseño de programas, todo programa en java debe ser inicializado, conceptualizado y visto como una clase, además todo programa Java arranca su operación desde la función main (principal). class NombreClase { public static void main (String [] args)

{ /* Cuerpo del programa principal */ } } La función main siempre debe ser vista como el punto de arranque para el diseño y operación del programa completo, mas adelante veremos que los objetos no son mas que estructuras de datos complejas (es decir, tipos de datos abstractos) que interactúan entre sí. Dentro de ellos es posible crear progrmas muy simples que demuestren el


24

comportamiento completo de las sentencias de control e inclusive desarrollar funciones simples que puedan realizar una acción especifica definida por el programador.

1.4.1 Sentencias de Control Las estructuras de decisión son estatutos condicionales que nos permiten la ejecución selectiva de porciones de programa (bloques de código) de acuerdo al valor de una expresión. Java soporta los estatutos if y switch, que nos permiten ramificaciones de ejecución en dos o mas ramas.

Sentencia if – else La sintaxis de la sentencia es: if ( <expresión booleana>) [ { ] <bloque de estatutos si la expresión es cierta> [ } ] else [ { ] <bloque de estatutos si la expresión es falsa> [ } ] Ejemplo: public class EjemploIF {

public static void main(String [] arg) { int x = (int)(Math.random() * 100); if (x > 50) System.out.println("Mayor a 50 "+x); else { System.out.println("Menor a 50 "+x); x = 0; } } }

Sentencia switch La sintaxis de la sentencia es: switch ( <expresión>) { case <constante1> :

<bloque de estatutos> [break;]

case <constante2> : <bloque de estatutos> [break;]

default : <bloque de estatutos> [break;]

} En el estatuto switch el valor de la expresión debe ser compatible con un entero y puede existir la promoción.


25

La etiqueta default especifica que el segmento de código será ejecutado si el valor de la expresión nunca coincide con alguno de los casos. Una estatuto return puede ser usado en lugar de break. Además, si switch esta en un ciclo, el estatuto continue permitira la salida del estatuto switch. Por ejemplo: class Switch1{ public static void main(String args[]) { int k = (int)(Math.random() * 16); switch(k){ case 2: System.out.println(" case k = 2"); break; case 4: System.out.println(" case k = 4"); break; case 8: System.out.println(" case k = 8"); break; default: System.out.println(" case default " + k); } } } Las estructuras de repetición nos permiten ejecutar bloques de código de manera repetitiva. Java soporta 3 tipos de estructuras de repetición: for, while y do. Los ciclos for y while, verifican la condición antes de ejecutar el bloque del ciclo. Mientras que do ejecuta el bloque de código y verifica la condición al final.

Sentencia for La sintaxis para el estatuto for es: for(<inicia expresión>; <verifica expresión>; <altera expresión>) [{] <estatuto o bloque> [}] Ejemplo: public class ForLoop { public static void main(String[] args) { for ( int i = 0; i < 10; i++ ) System.out.println(i + " el cuadrado es " + (i*i)); } }


26

Ejemplo: import static java.lang.System.out; class Prueba { public static void main(String [] args) { int [] x = {2,3,5,6,4,1,0},

y = {5,4,2,1,3,6,7}; int r = 0; for (int i = 0; i < x.length; i++) r+= (x[i] * y[i]); out.println("producto escalar es " + r); return; } }

Sentencia while La sintaxis para el estatuto while es: while (<verifica expresión>) [{] <estatuto o bloque> [}] class While { public static void main(String [] arg) { int i = 1; while (i < 5) { System.out.println("i = "+ i); i++; } } }

Sentencia do - while La sintaxis para el estatuto do/while es: do [{] <estatuto o bloque> [}] while (<verifica expresión>) class DoWhile { public static void main(String [] arg) { int i = 1; do { System.out.println("i = "+ i); i++; } while (i < 5); } }


27

Sentencia break, continue y return En algunos casos se tendrá la necesidad de eliminar o modificar la iteración en bucle de control, para ello se pueden emplear las etiquetas break y continue. • break: Rompe el flujo de un bloque switch y de repetición mas cercano a él. Lo que

provoca que el flujo de control sea roto y se salga intempestivamente de ciclo. do { lista-de-estatutos; if (condición) { break; } lista-de-estatutos; }while(expresion); //break provoca que el flujo continué aquí • continue: Realiza un salto al final del ciclo de control (verificación) y se reintegra al

ciclo de control. do { lista-de-estatutos; if (condición) { continue; //regresa a do } lista-de-estatutos; } while (expresion); • return: Realiza el regreso de llamada a función en cualquier punto que se encuentre.

Sentencia for-each Es una sentencia que actúa con elementos que son catalogados como elementos iteradores. class Prueba { public static void main(String [] args) { int [] x = {2,3,5,6,4,1};

out.println("el vector es "); for ( int i : x ) System.out.print( i + " "); return; } }

1.4.2 Métodos estáticos La forma más sencilla de realizar programas de manera estructurada en java es empleando funciones o métodos estáticos, que son procedimientos o subrutinas medianamente independientes pero muy poco alejados del manejo de datos como en las clases. En realidad un método estático está involucrado de manera local a la clase que lo construye. Hasta el momento solo realizaremos métodos estáticos, pues necesitamos adquirir cierta habilidad antes de retomar nuevamente la construcción de clases.


28

Como ya hemos mencionado la unidad mínima de programación en java es la clase, de manera que los métodos estáticos o procedimientos estarán declarados dentro de la clase, la sintaxis para la declaración de procedimientos estáticos es la siguiente: <modificador> class NombreClase { public static void main( String [] args ) { } <modificador> static <tipo> nombreProcedimiento(<argumentos>)

{ // declaración de variables locales // lista de sentencias } } Los modificadores de acceso permiten determinar el alcance del procedimiento en este caso será public, debido a que pretendemos que el procedimiento sea visto desde fuera de la clase principal, en otro caso podría ser omitido de manera que el procedimiento solo será visto de manera local a la clase (o paquete). El modificador static determina que se trata de un procedimiento de clase por lo que no será necesario construir un objeto de la clase para poder emplear dicho procedimiento. El tipo de dato que regresará el procedimiento varía según del tipo y características de la función, los tipos de datos disponibles podrían ir desde tipos de datos nativos (int, flota, void, char, etc) hasta tipos de datos referenciados (arreglo, String, wrapper o un tipo de dato definido por el usuario “un objeto de clase”). La lista de argumentos son todos aquellos valores que requieren ser enviados a una función para que pueda realizar sus sentencias, estos argumentos pueden ser desde tipos de datos nativos hasta referenciados. Es importante recordar que las variables definidas dentro de los métodos son llamadas variables locales (algunas veces llamadas variables automáticas, temporales o de pila), éstas deben ser inicializadas explícitamente antes de ser usadas y son vistas únicamente por la función. Suponga que requerimos construir un procedimiento suma que nos permita sumar un par de valores: public class Main {

public static void main(String[] args) { int x = 1, y = 2, z; z = suma(x,y); System.out.print("el resultado es " + z); } static int suma(int a, int b){ return a+b; } }


29

Observe que el modificador de acceso puede ser omitido si se trata de una función local a la clase principal, de manera que el procedimiento recibe un par de valores y devuelve el resultado. import static java.lang.System.out; class Prueba { public static void main(String [] args) { int [] x = {2,3,5,6, 9,1,0}; out.println("la sumatoria es " + suma(x)); } static int suma( int [] tem ) { int r = 0; for (int i = 0; i < tem.length; i++) r+= tem[i]; return r; } } Inclusive podemos integrar el concepto de sobrecarga que ya se tiene claramente entendido: class Prueba { public static void main(String [] args) { int [] x = {2,3,5,6, 9,1,0}; int val = 10; out.println("suma x[0] y val "+suma(x[0], val)); out.println("la suma del arreglo " + suma(x)); return; } static int suma(int a, int b){ return a+b; } static int suma( int [] tem ) { int r = 0; for (int i = 0; i < tem.length; i++) r+= tem[i]; return r; } } Las variables locales son creadas cuando se realiza la ejecución de un método y son destruidas al finalizar el método, a esto se debe el nombre de variables temporales. Las variables locales deben ser inicializadas manualmente antes de ser usadas. El compilador genera un error si puede determinar una condición donde las variables son usadas antes de ser inicializadas. En la siguiente unidad veremos mas a detalle esta característica de construcción de programas empleando el mecanismo de orientación a


30

objetos. Por el momento emplearemos solo funciones estáticas a la clase para elaborar programas sencillos. Una forma alternativa y quizas mas correcta del programa anterior sería: public class Main { public static void main(String [] args) { int [] x = {2,3,5,6, 9,1,0}; int val = 10; out.println("suma x[0] y val " + A.suma(x[0], val)); out.println("suma del arreglo " + A.suma(x)); return; } } class A { static int suma(int a, int b){ return a+b; } static int suma( int [] tem ) { int r = 0; for (int i = 0; i < tem.length; i++) r+= tem[i]; return r; } } Como podra darse cuenta se esta construyendo una clase que contiene los metodos estaticos y en su momento se le solicita a la clase que los ejecute. Otras implmentaciones simples de los métodos ya vistos son los siguientes: class Vector { public static void main(String [] args) { int [] x = {2,3,5,6,4,1,0}, y = {5,4,2,1,3,6,7}; System.out.println("producto escalar" + prodEscalar(x,y)); return; } static int prodEscalar( int [] a, int [] b ) { int r = 0; for (int i = 0; i < a.length; i++) r+= (a[i] * b[i]); return r; } }


31

Ejemplo: class Matriz { public static void main(String [] args) { int [][] x = {{2,3},{5,6},{4,1}}; double [][] r = null; double e = 4.0; r = matPorEscalar(x,e); System.out.println("la matriz es "); mostrar(r); return; } static double [][] matPorEscalar( int [][] tem, double n ) { double [][] res =

new double [tem.length][tem[0].length]; for (int i = 0; i < tem.length; i++) for (int j = 0; j < tem[i].length; j++) res[i][j] = tem[i][j] * n; return res; } static void mostrar( double [][] tem) { for (int i = 0; i < tem.length; i++) { for (int j = 0; j < tem[i].length; j++) System.out.print(tem[i][j] + " "); System.out.println(); } return; } } Ejemplo: class Prueba { public static void main(String [] args) { int [] x = {2,3,5,6,4,1}; out.println("la matriz es "); mostrar(x); return; } static void mostrar( int [] tem) { for ( int i : tem ) out.print( i + " "); return; } }


32

1.4.3 Aplicando sentencias de control y métodos estáticos A continuación emplearemos el diseño de una función estática muy simple con el objetivo de ver la independencia de la función y mostrar de manera clara lo referente al paso de parámetros que sigue siendo parte fundamental en la construcción de herramientas modulares. public class Sumatoria { public static void main( String args[] ) { int f = 5, c = 2; double m[][] = new double [f][c]; System.out.print("numero de filas " + f); System.out.print("numero de columnas " + c); for ( int i = 0; i < m.length; i++ ) { for ( int j = 0; j < m[i].length; j++ ) m[i][j]= Math.random(); } for ( int i=0; i < m.length; i++ ) { for ( int j=0; j < m[i].length; j++ ) System.out.print(" ("+ i +"," + j + ") -> "

+ m[i][j]); System.out.println(); } System.out.println(" sumatoria " + sumatoria(m)); System.exit(0); } public static double sumatoria(double [][] lista) { double total = 0; for( int i = 0; i < lista.length; i++ ) for ( int j = 0; j < lista[i].length; j++ ) total += lista[i][j]; return total; } } Es importante observar como el paso de parámetros se puede realizar con cualquier tipo de dato reconocido por la sintaxis de java, en éste caso tomamos una matriz y la enviamos como parámetro a una función que se encargara de procesarla para una sumatoria de sus elementos que la componen, al final regresa como valor el resultado de dicha operación. Una versión un poco distinta, pero versando sobre la misma idea de manipulación de datos compuestos como las matrices es la siguiente, observe que en éste caso se emplean un par de procedimientos. El primero se encarga de recolectar los datos para llenar una matriz con números aleatorios, posteriormente los datos son transferidos a una matriz local a la función main la cual se encargara de transferir dicho dato a otro procedimiento vacío(void).


33

public class Captura { public static void main( String args[] ) { int filas = 5, columnas = 2; double matriz[][] = llenadoAleatorio(filas, columnas); mostrar(matriz); return; } static double [][] llenadoAleatorio(int f, int c) { double mat[][] = new double [f][c]; //matriz local System.out.println("filas, columnas " + f+","+c); for ( int i = 0; i < mat.length; i++ ) { for ( int j = 0; j < mat[i].length; j++ ) mat[i][j]= Math.random();//llenado aleatorio } return mat; //matriz de regreso } static void mostrar(double [][] mat){ for ( int i=0; i < mat.length; i++ ) { for ( int j=0; j < mat[i].length; j++ ) System.out.print(" ("+ i +"," + j + ") -> "+

mat[i][j]); System.out.println(); } return; } } Finalmente una versión alternativa para la suma de matrices podría verse de la siguiente manera: public class Matrices { public static void main(String[] args) { // TODO code application logic here double [][] x = {{1,2},{3,4}}; double [][] y = {{4,3},{2,1}}; double [][] res = suma( x, y ); mostrar(res); } public static double [][] suma(double [][] a,double [][] b){

if (a.length != b.length || a[0].length != b[0].length) return null; double [][] calc = new double [a.length][a[0].length]; for (int f = 0; f < calc.length; f++) for(int c = 0; c < calc[f].length; c++) calc[f][c] = a[f][c] + b[f][c]; return calc; }


34

public static void mostrar( double [][] m ) { for (int f = 0; f < m.length; f++){ System.out.println(); for(int c = 0; c < m[f].length; c++) System.out.print(m[f][c]+"\t"); } } } Ejemplo: import java.util.Scanner; public class Main { public static void main(String[] args) { System.out.print("valor de m y n"); Scanner cin = new Scanner(System.in); int m = cin.nextInt(); int n = cin.nextInt(); System.out.println(" res " + a(m,n)); } static int a(int m, int n) { if (m == 0) return n + 1; if (m > 0 && n == 0) return a(m - 1, 1); //if(m > 0 && n > 0) return a(m -1, a(m, n -1)); } }

1.5 Funciones de entrada y salida estándar La mayoría de las aplicaciones deben interactuar con el usurario. Dichas interacciones están algunas veces acompañadas con datos de entrada y de salida a la consola (usando el teclado como entrada estándar y la ventana de Terminal como salida). Java soporta la entrada y salida de datos desde consola empleando 3 tipos de variables, que están contenidas en la librería de clases de java (System). Referenciada como java.lang.System: • La variable System.out es un objeto PrintStream que se refiere (inicialmente) a la

ventana de Terminal donde las aplicaciones son ejecutadas. • La variable System.in es un objeto InputStream que se refiere (inicialmente) al

teclado del usuario. • La variable System.err es un objeto de tipo PrintStream que se refiere

(inicialmente) a la ventana de Terminal. El manejo de entrada y salida de datos en java no es uno de los más eficientes entre los lenguajes de programación actuales, de hecho resulta bastante frustrante al inicio, pero gradualmente se llega a entender el mecanismo empleado principalmente empleado en la entrada de datos estándar.


35

1.5.1 Salida de datos por pantalla La salida de datos se realiza a través de la función print y println del objeto System.out, esto indica que la salida de datos será directa. Los métodos imprimen objetos Strings por defecto por lo que no es necesario indicar la tipificación en una plantilla. El método print imprimirá strings (elementos concatenados) directamente en la salida y el cursos permanecerá en el punto siguiente a la impresión, por el otro lado println imprimirá un salto de línea después de su ejecución. System.out.println(“Valor ” + 12 + “ “ + “valor ” + 12.22);

1.5.2 Lectura de datos por teclado La entrada de datos se puede realizar básicamente de 3 maneras distintas, partiremos desde un esquema que se empleaba en un inicio y llegaremos hasta un esquema muy sencillo que se emplea en las versiones más recientes. Entrada de flujo de bytes – es uno de los esquemas mas empleado en las primeras versiones de java, empleamos la llamada al método read() del objeto System.in. Desafortunadamente es indispensable emplear el bloque try…catch, pues la capturan filas de bytes provoca errores. Debido a esta deficiencia en el funcionamiento, es necesario depositar los bytes en un arreglo de caracteres, y así posteriormente ser transformados a tipos nativos como texto (string), entero o real. Para esto emplearemos un objeto de la clase StringBuffer que permita manipular un String como pila de caracteres, depositando cada uno de los caracteres capturados desde teclado. import java.io.*; public class Captura1 { public static void main(String[] args) { String str; // creamos un objeto para depositar los caracteres System.out.print("Dame un texto "); StringBuffer buffer = new StringBuffer(); char c; try { // capturamos caracteres hasta encontrar un enter while ( (c = (char) System.in.read() )!='\n' ) buffer.append(c); //los concatenamos en el buffer } catch(IOException ex){ }// convertimos el buffer en string str = buffer.toString().trim(); System.out.println("la cadena 1 es " + str ) //eliminamos el contenido para usarlo nuevamente buffer.delete(0,buffer.length()); float valor; // capturamos ahora un numero System.out.print("Dame un numero "); try { // capturamos caracteres hasta encontrar un enter while ( (c = (char) System.in.read() )!='\n' ) buffer.append(c); } catch(IOException ex) { } // convertimos el buffer en flotante valor = Float.parseFloat(buffer.toString().trim()); System.out.println("el valor es " + valor); } }


36

Entrada de flujo de caracteres – la captura de bytes es muy complicada, en su lugar resulta más sencillo capturar caracteres Unicode, para esto se desarrollaron dos objetos que podrían facilitar esta tarea. InputStreamReader es una clase que nos permite direccionar el flujo de entrada a algún dispositivo especifico, en este caso System.in. Una vez que esta indico el flujo de entrada, es necesario almacenar los caracteres entrantes en un objeto String, para ello emplearemos un objeto BufferedReader el cual nos permitirá almacenar la entrada de datos. import java.io.*; public class Captura2 { public static void main(String [] arg) { String s; // crea un lector de buffer para leer cada linea de teclado InputStreamReader lector = new InputStreamReader(System.in); // crea un buffer para almacenar la entrada de lector BufferedReader in = new BufferedReader(lector); System.out.print("captura de texto "); try { // captura los datos de teclado s = in.readLine(); System.out.println("texto :" + s); } catch(IOException e) {} System.out.print("captura de valor "); try { // captura los datos de teclado s = in.readLine(); int valor = Integer.parseInt(s); //regresa el numerico System.out.println("valor :" + valor); in.close(); // cerramos el flujo de entrada } catch(IOException e) {} } } Entrada de flujo de tipos primitivos y strings – en la versión 5 de java se incorporo un mecanismo que nos permite manipular la entrada de datos de manera, transparente y menos complicada. Para la captura se emplean expresiones regulares, es decir, el objeto fragmenta la entrada de datos en componentes o unidades independientes separadas por espacios en blanco. La clase Scanner cuenta con bastantes métodos que facilitan la captura de datos, a continuación se presenta un ejemplo sencillo de su uso, se deja al alumno investigar mas al respecto. import java.util.Scanner; public class Captura3 { public static void main(String [] arg) { Scanner s = new Scanner(System.in); //direccionamos System.out.println("ingresa el texto "); String str = s.next(); //leemos alfanumericos System.out.println("la cadena es "+ str); System.out.println("ingresa el numero "); float valor = s.nextFloat(); //leemos flotantes System.out.println("el numero es "+ valor); s.close(); } }


37

1.5.3 Ventanas de Dialogo simple para manejo de datos Trabajar con la entrada de datos de consola, suele ser en ocasiones un fastidio ya que si los datos no fueron introducidos correctamente se romperá el flujo normal del programa; en estos casos un cuadro de dialogo simple puede ayudarnos a capturar y enviar información a una pantalla emergente. La Creación de cuadros de diálogo simples se realiza empleando objetos de tipo JOptionPane (javax.swing.JOptionPane).

Salida de datos showMessageDialog Para la salida de datos simplemente aparecerá un cuadro emergente indicando el mensaje y aparecerá integrado un botón que permite el flujo del programa. • //título e icono por defecto

JOptionPane.showMessageDialog(null,"Texto del mensaje.");

• //título personalizado, icono de aviso JOptionPane.showMessageDialog(null,"Texto del mensaje.",

"Título del marco", JOptionPane.WARNING_MESSAGE); • //título personalizado, icono de error

JOptionPane.showMessageDialog(null,"Texto del mensaje.", "Título del marco", JOptionPane.ERROR_MESSAGE);

• //título personalizado, sin icono

JOptionPane.showMessageDialog(null,"Texto del mensaje.", "Título del marco", JOptionPane.PLAIN_MESSAGE);

Entrada de datos showInputDialog La entrada de datos puede realizarse de manera muy simple con este tipo de dialogo, el tipo de dato que regresa es un String, el cual puede ser opcionalmente promovido (cast). Una vez obtenido el valor puede emplearse algún método de los Wrappers para transformarlo a numero. //pedir la introducción de texto String s = (String)JOptionPane.showInputDialog(null,

"Texto del mensaje:\n","Título del marco", JOptionPane.PLAIN_MESSAGE);

Salida de datos showConfirmDialog Tambien es posible determinar entre realizar o no una opción: int r = JOptionPane.showConfirmDialog(null, "pregunta?"); if( r == JOptionPane.YES_OPTION )

JOptionPane.showMessageDialog(null, "Si"); else if( r == JOptionPane.NO_OPTION )

JOptionPane.showMessageDialog(null, "No");


38

Observe el siguiente ejemplo que muestra el uso de los objetos showInputDialog y showMessageDialog: import static java.lang.System.out; import javax.swing.*; public class Dialogos { public static void main( String args [] ) { String s = (String)JOptionPane.showInputDialog(null, "filas?\n","Input",JOptionPane.PLAIN_MESSAGE); int f = Integer.parseInt(s); s = (String)JOptionPane.showInputDialog(null, "columnas?\n","Input",JOptionPane.PLAIN_MESSAGE); int c = Integer.parseInt(s); double [][] m = new double [f][c]; JOptionPane.showMessageDialog(null, "filas " + f+'\n' +"columnas " + c); for ( int i = 0; i < m.length; i++ ) for ( int j = 0; j < m[i].length; j++ ) m[i][j]= Math.random(); for ( int i=0; i < m.length; i++ ) { for ( int j=0; j < m[i].length; j++ ) out.print(" ("+ i +"," + j + ") -> " + m[i][j]); out.println(); } } }

1.6 Clase Math Las funciones matemáticas siempre son necesarias para construir ciertas operaciones que de otra forma resultarían muy complicadas, Java cuenta con una clase llamada Math que tiene asociada un número determinado de funciones, como hemos visto en el ejemplo anterior la función random es capaz de generar un valor aleatorio de tipo double que es asignado a una variable de ese tipo. A continuación se mencionan algunas de las funciones estaticas de Math más comunes, aunque es importante recordar que se cuentan con muchas más: o Math.abs(x), que calcula el valor absoluto de un valor x. o Algunas funciones trigonometriítas como Math.sin(x), Math.cos(x), Math.tan(x). o Math.pow(x,y), que calcula el valor de x elevado a la y o La funcion Math.floor(x) que redondea a un valor proximo inferior y Math.round(x)

que regresa un valor entero cercano a x. o Math.random(), que genera valores aleatorios en el rango de 0.0 <= x < 1.0.


39

Glosario de términos • Atributo: es el conjunto de características que define las propiedades de un objeto,

generalmente se conocen como variables del objeto. • Clase: es un programa de computadora que construye, destruye y especifica la información,

las operaciones y los métodos, de objetos de un mismo tipo (equivale a la generalización de un objeto). De esta forma, los objetos son entonces instancias o ejemplares de las clases

• HTML: Lenguaje de hipertexto empleado para construir paginas en Internet • IDE: Ambiente de desarrollo integral (Integrated development environment). • Java: Lenguaje de programación orientado a objetos multiplataforma • Java Applets: Pequeños programas automatizados que pueden ser incrustados en paginas

Web. • JRE: Ambiente de ejecución para aplicaciones Java • JSDK: Conjunto de herramientas para el desarrollo de aplicaciones Java • JVM: Maquina virtual de Java (Java Virtual Machina). • Métodos: son pequeños programas o procedimientos altamente independientes asociados a

características especificas del objeto. • Objetos: son cajas negras que mantienen ocultas propiedades estructurales llamadas atributos,

y propiedades de comportamiento llamadas operaciones o métodos. Package – los paquetes son colecciones de clases distribuidas (organizadas) en directorios y por lo general se encuentran relacionadas entre si. El nombre de los paquetes se escriben en minúsculas. package proyecto.objetos Clases – los nombres de las clases deben ser sustantivos (desde un punto de vista meramente didáctico se le define como el tipo de palabra que significa persona, animal o cosa concreta o abstracta), en algunos casos mezclados, con la primera letra de cada palabra en mayúscula. class EjemploUno Método – los nombres de los métodos deben ser verbos, con palabras mezcladas, con la primera letra en minúscula. En caso de emplear mas palabras se le recomienda hacer la primera letra mayúscula. calculaPromedio() Variables – todas las variables pueden ser mezclas de palabras procurando emplear la letra minúscula para la primera y empleando las letras mayúsculas para separar al resto de las palabras. apellidoPaterno Procure limitar el empleo de variables simples (a, b, …, x) para el manejo de bucles de control.


40

Constantes – se recomienda el uso de las constantes con letras mayúsculas, separando las palabras con guión inferior. TOPE_MAXIMO Bibliografía Nell Dale, Chip Weems, Mark Headington, Programming and Problem Solving whith Java, Jones & Bartlett, 2005, ISBN: 0-7637-3069-6. Luis Joyanes Aguilar y Matilde, Java 2 Manual de programación, Osborne-Mc Graw Hill. http://download.oracle.com/javase/6/docs/api/java/lang/Number.html http://download.oracle.com/javase/6/docs/api/java/lang/Character.html http://download.oracle.com/javase/6/docs/api/java/lang/Boolean.html

1. Introduccion Java

Documents

Transcript of 1. Introduccion Java