1

1 Conceptos Básicos.

1.1 Tipos de Datos Primitivos Los tipos de datos son conjuntos de elementos que cumplen con unas características bien definidas, de manera que es posible determinar si un elemento dado pertenece a él o no. En java se habla de dos grandes grupos de tipos de datos: los primitivos y los referenciados. Los tipos de datos primitivos son comunes a casi todos los lenguajes de programación, y tienen como característica principal el que sus instancias son valores, además no se puede definir un nuevo tipo de dato, se debe trabajar con los que ofrece java. Los tipos referenciados agrupan clases, interfaces y arreglos; a sus instancias se les denomina objetos. Los lenguajes de programación orientados a objetos, ofrecen un grupo grande de estos tipos, al cual se denomina API, pero, a diferencia de los tipos de datos básicos, el programador puede definir nuevos tipos de estos datos. En este curso se trabajará con dos tipos referenciados, los arreglos y los que se definen a través de clases.

Un tipo de dato primitivo es la definición de un grupo de valores y de las operaciones que se que existen para trabajar con ellos. Como ejemplo de tipos de datos se pueden citar, en matemáticas, los números naturales y los números enteros. Se habla de los números naturales, como los números enteros mayores o iguales a cero; y se sabe que para ellos están definidas las operaciones suma y multiplicación sin ninguna restricción, además está la resta, siempre y cuando el minuendo sea mayor que el sustraendo, y la división siempre y cuando el divisor sea diferente de 0 y se pueda encontrar otro número natural tal que al multiplicar este número por el divisor se obtenga el dividendo. También existen los números enteros, que se extienden desde el infinito negativo hasta el infinito positivo; para estos números también se han definido operaciones, entre ellas la suma, la resta y la multiplicación sin ninguna restricción, pero la división sigue teniendo las mismas restricciones que para los números naturales.

Defina con sus propias palabras qué es un tipo de dato.

Recuerde los tipos que ha definido en forma previa: en ciencias sociales estudió los departamentos que conforman un país, así como los municipios que están en un departamento; en ciencias naturales, estudio los seres vivos, y a partir de ellos definió los animales, los vegetales, los protistos, los móneras y los fungi;

2

y, tal como se mencionó en el párrafo previo, las formas de agrupar los números, también definen tipos de datos. En java, se cuenta con estos tipos primitivos: • Datos de tipo booleano [boolean]: el grupo de valores que maneja este tipo de

dato comprende aquellos valores empleados para definir el valor de verdad de algo: falso y verdadero, las operaciones permitidas para estos datos son las denominadas operaciones lógicas. Específicamente, en java, se manejan los valores false y true.

• Datos de tipo numéricos: • Datos de tipo byte [byte]: trabaja el rango de valores más pequeño, pues

sólo puede guardar valores enteros entre -128 y +127. La razón de su tamaño es el número de bits que se utiliza en memoria para guardarlo, que en este caso es 8, de ahí su nombre, pues 8 bits forman un byte. Al igual que todos los tipos de datos numéricos, con estos valores se pueden realizar operaciones aritméticas, de relación y de asignación.

• Datos de tipo entero pequeño [short]: también está definido para trabajar con valores enteros, y el rango que puede albergar está entre -32.768 y +32.767.

• Datos de tipo entero estándar [int]: contiene, de nuevo, valores enteros, y el rango que puede albergar está entre -2.147'483.648 y +2.147'483.647.

• Datos de tipo entero grande[long]: trabaja con valores numéricos enteros y el rango va desde -9'223.372'036.854'775.808 (¡menos nueve trillones doscientos veinte tres mil tres cientos setenta y dos billones treinta y seis mil ocho cientos cincuenta y cuatro millones setecientos setenta y cinco mil ocho cientos ocho!) y +9'223.372'036.854'775.807.

• Datos de tipo caracter [char]: con este tipo de dato debe hacerse claridad, pues a pesar de ser considerado un valor entero, por java, lógicamente se debe tratar como un caracter. Contiene la posición en la cual se encuentra cada caracter en la tabla Unicode1, es decir comprende valores entre 0 y 65536.

• Datos de tipo real con precisión simple [float]: este rango comprende datos de tipo real, y su rango de valores está definido, de acuerdo al estándar de la IEEE2 para este tipo de números, reservando un bit para el signo, ocho bits para el exponente y veinticuatro bits para la mantisa. La precisión que se maneja es de 7 dígitos, aproximadamente. Se recomienda no emplear este tipo, pues puede llevar a resultados poco precisos.

• Datos de tipo real con precisión doble [double]: también maneja datos de tipo real y su capacidad es mayor que la del tipo anterior. De nuevo, se acoge al estándar de la IEEE, y emplea un bit para el signo, 11 bits para el exponente y 52 para la mantisa. Maneja una precisión, aproximada, de 15 dígitos.

1 http://www.unicode.org/

2 754-1985 IEEE Standard for Binary Floating-Point Arithmetic

3

Los tipos de datos referenciados definen lo que debe tener “algo” para que sea considerado parte del grupo, y qué servicios puede prestar con aquello con que cuenta. En la primera parte de este libro se trabajará con algunos tipos de datos que se forman parte del API de java, como son los arreglos, java.util.Scanner, java.lang.String, java.util.ArrayList; y sólo en la segunda parte se tratará lo correspondiente a la creación de nuevos tipos referenciados, a través de clases.

Antes de entrar en materia, es importante hacer una aclaración sobre la forma en la cual java organiza los tipos referenciados, pues emplea una estructura similar a la de las carpetas, o directorios, que usan los sistemas operativos; pero los denomina paquetes. Al dar nombre a una clase, así se hará referencia a este tipo de dato en adelante, se incluye el paquete que la contiene, por eso java.util.Scanner, dice que la clase que se va a trabajar se llama Scanner y está ubicada en el paquete java.util; pero, por simplicidad en adelante se omitirá el nombre del paquete.

1.2 Literales Un literal es un valor perteneciente a alguno de los tipos de datos presentados en el ítem anterior, una cadena de caracteres (String), o null, que es la representación de un valor nulo en java. • Literales enteros: tienen las siguientes características:

• Carecen de parte decimal. • Si no incluyen signo, se presumen positivos. • Se pueden escribir en tres sistemas de numeración:

• Octal, base 8: tienen que empezar con el número cero (0). • Decimal, base 10: no pueden empezar con el número cero. • Hexadecimal, base 16: tienen que empezar con el número cero y la letra

equis en minúscula (0x). • Se presumen de tipo int, excepto que incluyan una letra ele minúscula o

mayúscula (l o L) al final, o que su valor sobrepase la capacidad del tipo int; en estos dos casos se tratan como de tipo long.

• Literales reales: tienen las siguientes características: • Están formados por una parte entera y una parte decimal. • Pueden escribirse como:

• parteEntera.parteDecimal: la parte entera puede estar escrita en octal, decimal o hexadecimal, siguiendo las mismas convenciones que los literales enteros.

• valoreexponente / valorEexponente: corresponde a la notación científica. • Si no incluyen signo, se presumen positivos.

Es importante aclarar que estos dos últimos tipos de datos no deben emplearse en operaciones de relación, pues se pueden obtener resultados extraños, debidos al manejo de la precisión. Por tanto se recomienda que al elaborar condiciones se utilicen los tipos de datos enteros.

4

• Se presumen de tipo double, excepto que incluyan una letra f o F al final, en cuyo caso será de tipo float.

• Literales caracteres: tienen las siguientes características: • Están formados por un único símbolo, excepto que representen una

secuencia de escape. El símbolo puede ser un caracter de casi cualquiera de los idiomas escritos que existen en la actualidad, la única condición es que tiene que pertenecer al conjunto de caracteres Unicode. Las secuencias de escape son señales que se usan para indicar al computador que se desea algo, por ejemplo con \n se indica que se debe hacer un salto a la siguiente línea.

• Deben estar delimitados por comillas sencillas. • Literales de los tipos referenciados: como se mencionó antes, los literales de

este tipo de datos son objetos o instancias de una clase. • Literales de la clase String: tienen las siguientes características:

• Están formados por un o más símbolos, incluídos en la tabla Unicode, entre los cuales se pueden incluir secuencias de escape.

• Deben estar delimitados por comillas dobles.

Su profesor de español del colegio, al enterarse de que usted estaba estudiando Algoritmos, le preguntó si los literales podían asimilarse a lo “limón” entre los sustantivos o a “feo” entre los adjetivos. Él espera su respuesta.

Ejemplos:

Un String puede contener:

• “a”: una letra. • “&”: un símbolo. • “\n”: una secuencia de escape – esta significa cambiar de línea –. • “Hola”: una combinación de letras. • “1. Abrir”: una combinación de letras, números y símbolos. • “Un párrafo tan extenso como sea necesario; el cual puede incluir signos de

puntuación, números, o cualquier otro carácter que se considere necesario.”

Ejercicios Resueltos. • Clasifique cada uno de los siguientes valores, de acuerdo al tipo de dato al cual

corresponde. Si cabe en varias clasificaciones, dé la lista completa ordenada del tipo más pequeño al más grande.

'p' � es de tipo char. 8 � dentro de los enteros puede ser byte, entero corto, entero o entero grande; en los reales podría ser de precisión doble.

5

9.4 � es un real y se trata como de precisión doble, por no incluir la letra f al final. 03 � es un entero, y puede ser byte, entero corto o entero, y está en octal. 0x3 � es un entero, y puede ser byte, entero corto o entero, y está hexadecimal. '\n' � es un caracter, y es una secuencia de escape. true � es uno de los dos valores booleanos. 95289602114502.2568 � es un real y su precisión es doble. 83E-9 � es un real y equivale a 83 multiplicado por 10 elevado a -9. Su precisión es doble.

Ejercicios Propuestos. 1. Clasifique los siguientes valores, de acuerdo al tipo de dato al cual corresponde. Si

cabe en varias clasificaciones, dé la lista completa empezando por el tipo más pequeño y llegando al más grande. Si se trata de un literal mal construido, indique la razón. false �

marco �

"i" �

'5' �

10L �

895698542185871421e-9 �

1.3 Identificadores Un identificador es un nombre que se da a cada uno de los elementos que puede definir un programador cuando intenta resolver un problema. Para ilustrar esto con un ejemplo, se puede decir que los nombre que se da a variables, constantes y clases son identificadores. En java, deben cumplir con las siguientes reglas: • Puede contener letras, números y el símbolo de subrayado. También pueden

contener el símbolo de dólar ($), sin embargo debe evitar utilizarse, pues es el símbolo que emplea java para identificar elementos creados al compilar y puede ocasionar confusiones.

• Debe empezar con una letra o el símbolo de subrayado, se recomienda que empiece con una letra.

• Java diferencia las mayúsculas de las minúsculas, así que debe tener esto presente al definir y utilizar identificadores.

• No hay restricciones referentes a la longitud máxima de un identificador, así que se pude ser suficientemente claro.

• Por estándar, se utilizan las siguientes reglas: • Para las clases, debe empezar con mayúscula, y si está compuesto de varias

palabras cada palabra inicia con mayúscula. Por ejemplo, MiPrimerClaseEnJava.

• Para las variables, debe empezar con minúscula, y si está compuesto de varias palabras cada nueva palabra inicia con mayúscula. Por ejemplo, valorTotal.

6

• Para las constantes, se debe escribir todo el nombre en mayúsculas, y si está formado por varias palabras deben separarse con una rayita en la parte baja. Por ejemplo PORCENTAJE_IVA.

• Java acepta y reconoce las tildes, así que se deben utilizar identificadores que no incluyan errores de ortografía.

• Se recomienda no incluir números en los identificadores, pues son elementos que emplea el compilador para diferenciar los elementos definidos del usuario de los elementos definidos por el compilador del lenguaje.

¿A qué elemento de la vida diaria le parece que corresponden los identificadores?

1.4 Palabras reservadas

Las palabras reservadas o palabras claves son identificadores predefinidos en un lenguaje de programación, es decir, ya tienen un significado especial para el lenguaje. Por lo tanto, estas palabras no pueden emplearse como identificadores definidos por el usuario. Java maneja las siguientes palabras reservadas: boolean char byte short int long float double widefp strictfp new this super if else switch case break default for continue do while return throw try catch finally syncronized static abstract final private protected public class instanceof throws native transient volatile extends interface implements package import const goto void

Ejercicios Resueltos. • ¿Los siguientes identificadores son válidos?

1valor � no es válido, pues los nombres de los identificadores no pueden empezar con un número. valor1 � es válido, pues los nombres de los identificadores pueden contener números, siempre que no sea en la primera posición, por estándar debería emplearse valorUno.

Es importante resaltar que true, false y null no son palabras reservada, sino que son valores. Es por esto que no pueden ser utilizados como identificadores, ni pueden ser redefinidos.

7

$valor � es válido sintácticamente, pero no cumple con los estándares para identificadores. valor$1� es válido sintácticamente, pero no cumple con los estándares para identificadores. valorUno � es válido sintácticamente, y cumple con los estándares siempre y cuando sea el nombre de una variable. REVOLUCIONES_POR_MINUTO ���� es válido sintácticamente, y cumple con los estándares siempre y cuando sea el nombre de una constante. package � no es válido sintácticamente, pues es una palabra reservada por java. MiClase � es válido sintácticamente, y cumple el estándar si es el nombre de una clase. código � es válido sintácticamente, pues java reconoce las vocales tildadas. Cumple con el estándar si es nombre de una variable. mi_valor � es válido sintácticamente, pero no cumple con el estándar.

Ejercicios Propuestos. 1. ¿Los siguientes identificadores son válidos?

_1valor �

_valor1 �

VALOR �

a �

laclase �

native �

miMétodo �

void �

Double �

1.5 Comentarios

Un comentario es una anotación que se quiere hacer para explicar algo referente al código que se está produciendo. Lo que se incluya como comentario no será tenido en cuenta por el compilador. Se acostumbra incluir información que pueda ayudar a comprender el código elaborado. En java existen tres tipos de comentarios: • El comentario que ocupa una sola línea:

// esto se considera un comentario de una sola línea.

• El comentario de varias línea: / * esto se considera un comentario de una varias líneas. No importa que se haya cambiado de línea continua el comentario. */

• El comentario que debe ser tenido en cuenta por el documentador de java: /* * esto, también, se considera un comentario de una varias líneas. Cuando se pida a la herramienta java.doc que genere la documentación correspondiente a la clase que contenga este comentario, él será incluido. */

8

Ejercicios Resueltos. • ¿Los siguientes comentarios están bien construidos?

/* fecha de creación: mayo del 2.001 */ ���� está bien construido, incluso podría ocupar más de un renglón. // Esta operación realiza las siguientes acciones: primera: incrementa la variable valorUno segunda: la multiplica por 8. Tercera: guarda el valor en valorDos � no está bien construido, pues este comentario no puede abarcar más de un renglón. /** valor1 es una variable que se utiliza en esta clase para contener el valor dado a los ítems, en forma unitaria */ ���� está bien construido y será incluido por javadoc al generar la documentación de la aplicación.

1.6 Variables Una variable es un identificador que guarda un valor o una referencia a un objeto, y su contenido puede ser modificado tantas veces como se requiera. En java las variables pueden ser declaradas en un punto determinado del código, y puede dárseles un valor inicial ahí mismo, o en un punto diferente, siempre que sea posterior al punto en el cual se definió. 1.7 Constantes Una constante es un identificador que guarda un valor o una referencia a un objeto, y su primer contenido no puede ser modificado. En java las constantes pueden ser declaradas en un punto determinado del código, y puede dárseles valor ahí mismo, o en un punto diferente.

Ejercicios Resueltos. • ¿Qué se está haciendo en los siguientes casos? ¿Es correcto?

int miValor = 0; � se está declarando una variable de tipo entero, llamada miValor, además se le está asignando cero (0) como valor inicial. Es correcto. final char respuesta; � se está declarando una constante llamada respuesta, de tipo char. No se le está asignando valor inicial. Es correcto. double valorReal = 250.1; int valorEntero = valorReal; � se declaran dos variables llamadas valorReal - como un real de precisión doble - y valorEntero - de tipo entero. A la primera se le asigna un valor - 250.1 -, luego a la segunda se le trata de asignar la parte entera de este valor. Es incorrecto. float valorSimple = 23e2f; double valorDoble = valorSimple + 100; � se declaran dos variables llamadas valorSimple - de precisión sencilla - y valorDoble - precisión doble. A la primera se le asigna un valor equivalente a 2300, luego a la segunda se le asigna este mismo valor incrementado en 100. Es correcto. int valorEntero = 250; double valorReal = valorEntero; � se declaran dos variables llamadas valorEntero - como un entero - y valorReal - como un real con precisión doble. A la primera se le asigna un valor - 250 -, luego a la segunda se le asigna la este valor. Es correcto.

9

double valorReal = 100.9; int valorEntero = (int) valorReal; � se declaran dos variables llamadas valorReal - como un real de precisión doble - y valorEntero - de tipo entero. A la primera se le asigna un valor - 100.9 -, luego a la segunda se le asigna la parte entera de este valor. Es correcto.

Ejercicios Propuestos. 1. ¿Qué se está haciendo en los siguientes casos? ¿Es correcto?

int 1Valor = 0; �

final char contestó = 'si'; �

double valorReal = 0x8E250; �

double otroValor = 0.050f; �

final boolean esteFue = 0; �

char letra = 'a' + 100; �

1.8 Operaciones Una operación es una combinación de uno o varios operandos y un operador, que devuelve un valor. Hay varios tipos, como son las aritméticas, las de relación, las lógicas, la unitaria, las de bits (las cuales no se incluyen en este libro), las de asignación y una condicional. • Aritméticas: Las operaciones aritméticas que ofrece java son la que

normalmente se trabajan en aritmética básica, es decir suma (+), resta (-), multiplicación (*), división (/) y módulo o residuo (%). Sin embargo hay varias cosas interesantes que anotar:

• Se aplican sobre los valores numéricos. • Si los valores son del mismo tipo no hay necesidad de hacer ningún tipo de

conversión, pero si son de diferente tipo, convierte todos los operandos al nivel del de mayor precisión. Al asignar el resultado a la variable correspondiente, trata de ajustar el valor al tipo de esta variable.

• Cuando debe pasar un valor real a una variable entera trunca el valor, es decir bota la parte decimal y guarda sólo la parte entera. Esta conversión no la hace en forma automática y hay que pedirlo a través de un cast. Es importante aclarar que esta operación, el cast, es necesaria siempre que se requiere pasar de un tipo de dato de mayor precisión a uno de menor. - Ver ejemplo en los ejercicios resueltos.

• Dado que el tipo char, en java, es un tipo entero se pueden hacer estas operaciones con variables y valores de este tipo. Sin embargo, el resultado puede carecer de significado, a menos que se conozca muy bien la tabla Unicode y se quiera hacer cambios de un símbolo a otro a través de estas operaciones.

• La división tiene un comportamiento ligeramente diferente al que uno podría esperar:

10

• si los operandos son reales el resultado será un valor real. • si los operandos son una mezcla de entero y real, el resultado será un

valor real. • si los operandos son enteros, el resultado será entero ¡aún si se guarda en

formato real!

Ejercicios Resueltos. • ¿Qué se está haciendo en los siguientes casos?¿Qué valor se obtiene?

• int valorUno = 3; double valorDos = 3.9; int resultado = (int)(valorUno + valorDos); � se define una variable entera llamada valorUno y se le asigna 3. Se define una variable real, llamada valorDos, y se le asigna 3.9. Se define una variable entera, resultado, y se le asigna el resultado de sumar las dos variables anteriores. Como el resultado de esta operación es un valor real, se hace el cast –(int) –, es decir que en resultado queda 6.

• double unValor = 9; int otroValor = 4; double resultado = unValor - otroValor; � se define una variable real llamada unValor y se le asigna el valor 9. Se define una variable entera, llamada otroValor, y se le asigna 4. Se define una variable real, resultado, y se le asigna el resultado de restar a unValor otroValor. En resultado queda 5.

• int valorUno = 2, valorDos = 4; double resultado = valorUno * valorDos; � se definen dos variables enteras llamadas valorUno y valorDos y se les asignan 2 y 4, respectivamente. Se define una variable real, resultado, y se le asigna el resultado de multiplicar las dos variables anteriores. En resultado queda 8.

• int resultado, valorUno = 8, valorDos=4; resultado = valorUno / valorDos; � se definen tres variables enteras llamadas resultado, valorUno y valorDos, a resultado no se le asigna nada y a las otros dos se les asignan 2 y 4, respectivamente. A resultado se le asigna el resultado de dividir valorUno entre valorDos, así que en resultado queda 2.

• int valorUno = 9, valorDos = 2; double resultado = valorUno / valorDos; � se definen dos variables enteras llamadas valorUno y valorDos, y se les asignan 9 y 2, respectivamente. Se define una variable real, resultado, y se le asigna el resultado de dividir valorUno entre valorDos, sin embargo como valorUno y valorDos son enteras se realiza una división entera, de manera que en resultado queda 4.0.

• int valorUno = 9; double valorDos = 2, resultado; resultado = valorUno / valorDos; � se define una variable entera llamada valorUno y se le asigna 9. Se definen dos variables reales, valorDos y resultado, y se le asigna a valorDos 2. A resultado se le asigna el resultado de dividir valorUno entre valorDos. Dado que resultado es real, y valorDos también, en resultado queda 4.5

• De relación: Permiten establecer una relación entre dos valores, que puede estar basada en la igualdad o la magnitud de estos valores, y retornan un valor

11

booleano. En este grupo están las operaciones menor (<), mayor (>), menor o igual (<=), mayor o igual (>=), igual (==) y diferente (!=).

•

Ejercicios Resueltos. • ¿Qué se está haciendo en los siguientes casos?¿Qué valor se obtiene?

• double valorUno = 1; int valorDos = 1; boolean compara = (valorUno < valorDos); � se define una variable real llamada valorUno y se le asigna 1. Se define otra variable entera, valorDos, y se le asigna 1. Se define otra variable booleana, compara, y se le asigna el valor obtenido al verificar si valorUno es menor que valorDos, es decir se le asigna false.

• double valorUno = 96; int valorDos = 100; boolean compara = (valorUno > valorDos); � se define una variable real llamada valorUno, se le asigna 96. Se define una variable entera, valorDos, y se le asigna 100. Se define una variable booleana, compara, a la cual se le asigna el valor obtenido al verificar si valorUno es mayor que valorDos, es decir se le asigna false.

• boolean compara; double valorUno = 15; int valorDos = 15; compara = (valorUno <= valorDos); � se define una variable booleana, llamada compara. Se define una variable real, llamada valorUno, se le asigna 15. Se define una variable entera, valorDos, y se le asigna 15. A la variable compara se le asigna el valor obtenido al verificar si valorUno es menor o igual que valorDos, es decir se le asigna true.

• boolean compara; double valorUno = 101; int valorDos = 100; compara = (valorUno >= valorDos); � se define una variable booleana, llamada compara. Se define una variable real, valorUno, y se le asigna 101. Se define una variable entera, valorDos, y se le asigna 100. A compara se le asigna el valor obtenido de verificar si valorUno es mayor o igual que valorDos, es decir se le asigna true.

• boolean compara; char valorUno = 'a', valorDos = 'b'; compara = (valorUno == valorDos); � se define una variable booleana, llamada compara. se definen dos variables de tipo caracter, valorUno y valorDos, a las cuales se les asignan los valores de ‘a’ y ‘b’, respectivamente. A compara se le asigna el valor obtenido de verificar si valorUno es igual que valorDos, es decir se le asigna false.

• boolean valorUno = false, valorDos = true; boolean compara = (valorUno != valorDos); � se definen dos variables booleanas, valorUno y valorDos, y se les asignan los valore false y true, respectivamente. Se define otra variable booleana, compara, a la cual se le asigna el valor obtenido de verificar si valorUno es diferente a valorDos, es decir se le asigna true.

12

• Lógicas: Permiten operar los valores true o false, obteniendo un único resultado acorde al operador lógico que se empleó. Se manejan los operadores correspondientes al y, al o, a la negación y al o exclusivo.

Java maneja dos casos especiales: Primero: Para el y existen dos operadores en java, el sencillo (&) el cual evalúa

ambos lados del operador y responde de acuerdo a la tabla de verdad de este operador; y el operador en corto circuito (&&), el cual evalúa el lado derecho, sólo si el izquierdo vale true.

Segundo: Para el o existen, también, dos operadores en java. El sencillo (|) el cual evalúa ambos lados del operador y responde de acuerdo a la tabla de verdad del o; y el operador en corto circuito (||), el cual evalúa el lado derecho, sólo si el izquierdo vale false.

Tablas de Verdad para los operadores:

y : & - && true & true = true true & false = false false & true = false false & false = false true && false = false true && true = true false && x = false

o: | - || true | true = true true | false = true false | true = true false | false = false false || true = true false || false = false true || x = true

negación: ! !true = false

!false = true

o exclusivo: ^ true ^ true = false true ^ false = true false ^ true = true false ^ false = false

Ejercicios Resueltos. • ¿Qué se está haciendo en los siguientes casos? ¿Qué valor se obtiene?

• boolean valorUno = true; boolean valorDos = false; boolean valorTres; valorTres = valorUno & valorDos; � se define una variable booleana llamada valorUno y se le asigna true.

13

Se define otra variable booleana, valorDos, y se le asigna false. Se define otra variable booleana, valorTres. A valorTres, se le asigna el resultado de operar con le y lógico, valorUno y ValorDos, es decir se le asigna false.

• int valor = 0; int otroValor = 10; boolean respuesta = (valor != 0) && (otroValor/valor > 0); � se define una variable entera, valor, a la cual se le asigna 0. Se define otra variable entera, otroValor, a la cual se le asigna 10. Se define una variable boolean, respuesta, a la cual se le asigna false. Dado que se utilizó el operador en corto, y se obtuvo false al evaluar la primera parte, no se evaluó la segunda.

• boolean valorUno = true; boolean valorDos = false; boolean valorTres; valorTres = valorUno | valorDos; � se define una variable booleana, valorUno, a la cual se le asigna true. Se define otra variable booleana, valorDos, a la cual se le asigna false. Se define una variable boolean, valorTres. A valorTres se le asigna el resultado de operar con o las variables valorUno y valorDos, es decir se guarda true.

• int unValor = 0; int otroValor = 10; boolean respuesta = (unValor == 0) || (otroValor/unValor > 0); � se define una variable entera, unValor, a la cual se le asigna 0. Se define otra variable entera, otroValor, a la cual se le asigna 10. Se define una variable boolean, respuesta, a la cual se le asigna true. Dado que se utilizó el operador en corto, y se obtuvo true al evaluar la primera parte, no se evaluó la segunda.

• boolean uno = true, dos; dos = !uno; � se definen dos variables booleanas, uno y dos. A uno se le asigna true. A dos se le asigna la negación de uno, es decir false.

• boolean valorUno = true; boolean valorDos = true; boolean valorTres; valorTres = valorUno ^ valorDos; � se definen una variable booleana, valorUno, y se le asigna true. Se define otra variable booleana, valorDos, a la cual se le asigna true. Se define una tercera variable boolena, valorTres. A valorTres se le asigna el resultado de operar con el o excluyente las otras dos variables. Es decir se le asigna false.

• De asignación: Modifican el valor de la variable sobre la cual se hace la asignación. Aunque se definieron para trabajar con valores, algunas de ellas se pueden usar con String, que es un tipo referenciado. Este grupo de operaciones es uno de los más grandes. Está el preicremento (++variable), el predecremento (--variable), el postincremento (variable++), el postdecremento (variable--), asignación (=), multiplica y asigna (*=), divide y asigna (/=), módulo y asigna (%=), suma y asigna (+=) y resta y asigna (-=).

Ejercicios Resueltos. • ¿Qué se está haciendo en los siguientes casos? ¿Qué valor se obtiene?

14

• int valorUno = 8; int valorDos = 3; valorUno = (++valorUno * valorDos); � se define una variable entera llamada valorUno y se le asigna 8. Se define otra variable entera, valorDos, y se le asigna 3. Se hacen tres operaciones, que por precedencia3, se resuelven en este orden: primero se hace el preincremento, es decir al contenido de la variable valorUno se le suma uno (queda con 9); se multiplica el valor obtenido por el contenido de la variable valorDos, el resultado obtenido se guarda en valorUno, es decir que valorUno queda con 27.

• valorUno = 8; valorDos = 3; valorUno = (valorUno++ * valorDos); � se define una variable entera llamada valorUno y se le asigna 8. Se define otra variable entera, valorDos, y se le asigna 3. Se hacen tres operaciones, que por precedencia, se resuelven en este orden: primero se hace el postincremento, es decir al contenido de la variable valorUno se le suma uno (queda con 9), pero se guarda una copia con el valor original (8); se multiplica el valor de la copia por el contenido de la variable valorDos, el resultado obtenido se guarda en valorUno, es decir que valorUno queda con 24.

• int valorUno = 8; int valorDos = 3; valorUno = (--valorUno * valorDos); � se define una variable entera llamada valorUno y se le asigna 8. Se define otra variable entera, valorDos, y se le asigna 3. Se hacen tres operaciones, que por precedencia, se resuelven en este orden: primero se hace el predecremento, es decir al contenido de la variable valorUno se le resta uno (queda con 7); se multiplica el valor obtenido por el contenido de la variable valorDos, el resultado obtenido se guarda en valorUno, es decir que valorUno queda con 21.

• valorUno = 8; valorDos = 3; valorUno = (valorUno-- * valorDos); � se define una variable entera llamada valorUno y se le asigna 8. Se define otra variable entera, valorDos, y se le asigna 3. Se hacen tres operaciones, que por precedencia, se resuelven en este orden: primero se hace el postdecremento, es decir al contenido de la variable valorUno se le resta uno (queda con 7), pero se guarda una copia con el valor original (8); se multiplica el valor de la copia por el contenido de la variable valorDos, el resultado obtenido se guarda en valorUno, es decir que valorUno queda con 24.

• int valorUno = 0;�se define una variable entera llamada valorUno y se le asigna 0. • String saludo = “Hola”; � se define una variable que referenciará una cadena de

caracteres, y se le dice que la cadena a referenciar es “Hola”. • int valorUno = 4;

valorUno *= 8; � se define una variable entera llamada valorUno y se le asigna 4. A valorUno, se le asigna el resultado de multiplicar su contenido con 8, es decir queda con 32.

• int valorUno = 32; valorUno /= 4; � se define una variable entera llamada valorUno y se le asigna 32. A valorUno, se le asigna el resultado de dividir su contenido entre 4, es decir queda con 8.

• int valorUno = 32; valorUno %= 4; � se define una variable entera llamada valorUno y se le asigna 32.

3 El tema de precedencia se presenta en el numeral 1.10

15

A valorUno, se le asigna el módulo obtenido al dividir su contenido entre 4, es decir queda con 0.

• int valorUno = 20; valorUno += 5; � se define una variable entera llamada valorUno y se le asigna 20. A valorUno, se le asigna el resultado de sumar a su contenido 5, es decir queda con 25.

• String saludo = “Hola”; saludo += “ ¿Cómo estás?”; � se define una variable que referenciará una cadena de caracteres, y se le dice que la cadena a referenciar es “Hola”. A saludo, se le asigna el resultado de concatenar su contenido con otra cadena; es decir queda referenciando “Hola ¿Cómo estás?”.

• int valorUno = 250; valorUno -= 7; � se define una variable entera llamada valorUno y se le asigna 250. A valorUno, se le asigna el resultado de restar a su contenido 7, es decir queda con 243.

• Unitaria: Opera sobre un único valor y es similar a la negación, pero para valores numéricos (equivale a multiplicar por -1).

• Condicional: Es un operador que dependiendo de un valor booleano, asigna

una de dos opciones a una variable; puede usarse para asignar valores o referencias a objetos. La sintaxis de este operador incluye los signos ? : y se emplea así:

variable a la cual se le asignará algo = (condición) ? lo que se debe asignar si la condición se cumple : lo que se debe asignar en caso contrario;

Ejercicios Resueltos. • Si el valor de una venta es mayor a una cantidad tope, se debe cobrar el 16% como

impuesto, en caso contrario no se cobra impuesto; además se debe mostrar un mensaje que indique si se cobrará impuesto o no.

• System.out.println(“Digite el valor tope, a partir del cual se calcula el impuesto”); double valorTope = lector.nextDouble(); System.out.println(“Digite el valor de la venta”); double valorVenta = lector.nextDouble(); double valorImpuesto = (valorVenta > valorTope) ? valorVenta * 0.16 : 0; String mensaje = (valorVenta > valorTope) ? “Se cobrará impuesto” : “No se cobrará impuesto”; � se pide al usuario el valor a partir del cual se cobrará el impuesto, y se define una variable real para guardar dicho valor (valorTope). se pide al usuario el valor de la venta, y se define una variable real para guardar dicho valor (valorVenta) se define la variable real valorImpuesto, a la cual se le asigna el 16% del valor de la venta, si el valor de la venta es superior al valor tope, en caso contrario se le asigna 0. se define una variable que referencia un objeto de la clase String, mensaje, a la cual se le asigna una referencia a la cadena “Se cobrará impuesto”, en caso de que el valor de la venta sea superior al tope, o a la cadena “No se cobrará impuesto” en caso contrario. Se define otra variable entera, denominada valorMayor, a la cual se le asigna el resultado de evaluar si valorUno es menor que valorDos, como no lo es, el operador condicional dice que se debe retornar lo que está a la derecha de los dos puntos, es decir retorna el contenido de valorUno.

• ¿Qué se está haciendo en el siguiente caso? ¿Qué valor se obtiene?

16

• int valorUno = 9, valorDos = 7; int valorMayor = (valorUno < valorDos) ? valorDos : valorUno; � se definen dos variables enteras llamadas valorUno y valorDos, se les asignan 9 y 7, respectivamente. Se define otra variable entera, denominada valorMayor, a la cual se le asigna el resultado de evaluar si valorUno es menor que valorDos, como no lo es, el operador condicional dice que se debe retornar lo que está a la derecha de los dos puntos, es decir retorna el contenido de valorUno.

1.9 Expresiones Una expresión es una combinación de operaciones, que devuelve un valor. Las más comunes son las expresiones numéricas, sin embargo no son las únicas. En java, las expresiones terminan con el símbolo punto y coma (;). 1.10 Precedencia. La precedencia indica, dado un grupo de operaciones contenidas en una expresión, el orden en el cual deben ser resueltas. java tiene una precedencia claramente definida, y sólo puede lograrse que se altere mediante la utilización de paréntesis (( )), pues de esta manera se garantiza que lo contenido dentro de los paréntesis será resuelto primero. La prioridad, en java, se muestra en la siguiente tabla:

Símbolo Aclaración Nivel (a mayor número mayor precedencia)

++ -- pre incremento o decremento 16 ++ -- post incremento o decremento 15 ~ operador para bytes 14 ! no lógico 14 - + signo del número 14 (nombre de tipo) conversión de tipos 13 * / % operadores de multiplicación 12 - + operadores de adición 11 << >> >>> operadores para bytes 10 instanceof < <= > >= operadores relacionales 9 == != operadores de igualdad 8 & y 7 ^ o exclusivo 6 | o inclusivo 5 && y condicional 4 || o condicional 3 ? : operadores de condición 2 = *= /= %= += -= <<= >>= >>>= &= ^= |= operadores de asignación 1

Si hay varios operadores con igual precedencia, las operaciones se resuelven de izquierda a derecha.

Ejercicios Resueltos. • ¿Qué se está haciendo en los siguientes casos? ¿Es correcto? ¿Qué valor devuelve?

• int miValor = 0; int nuevoValor = 8;

17

(miValor==0) ? miValor = nuevoValor : nuevoValor-= miValor; ���� se están declarando dos variables enteras - miValor y nuevoValor - , se le está asignando cero (0) como valor inicial, a la primera y ocho (8) a la segunda. Es correcto. miValor quedará valiendo 8 igual que nuevoValor. La secuencia de ejecución es: 2. Se crea la variable entera miValor. 3. Se le asigna como valor inicial cero (0). 4. Se crea la variable entera nuevoValor. 5. Se le asigna como valor inicial ocho (8). 6. Se aplica el operador condicional (?), y al evaluar si miValor es igual a cero, se

encuentra que es cierto, así que se ejecuta la acción que está a la izquierda de los dos punto (:), o sea que se asigna a miValor el valor que contiene la variable nuevoValor.

• double valorUno = 8.3; int nuevoValor = 8, resultado; resultado *= valorUno++ - nuevoValor; ���� se están declarando tres variables, la primera de ellas de tipo double, las otras dos de tipo int. Se inicializan dos de ellas, la primera (valorUno) con ocho punto tres, la segunda (nuevoValor) con 8. A la tercera no se le asigna valor inicial. Después se plantea una expresión aritmética, que es incorrecta por las razones que se dan en la secuencia de ejecución. La secuencia de ejecución es: 1. Se crea la variable double valorUno. 2. Se le asigna como valor inicial ocho punto tres (8.3). 3. Se crea la variable entera nuevoValor. 4. Se le asigna como valor inicial ocho (8). 5. Se crea la variable entera resultado. 6. No se le asigna valor inicial. 7. Se trata de resolver la expresión, pero se encuentran los siguientes errores: • resultado debe ser multiplicado por lo que se obtenga, sin embargo resultado no vale

nada pues no se le ha dado un valor inicial. • valorUno es de tipo double, y al tratar de resolver la expresión java tratará a nuevoValor

como de este tipo, luego el resultado que se obtendrá será de tipo double, y una variable int - como resultado - no puede recibir un valor de este tipo.

• La expresión correcta sería: resultado = (int) (valorUno++ - nuevoValor); // si no se quiere dar un valor inicial previo a resultado. resultado = 1; // o el valor indicado. resultado *= (int) (valorUno++ - nuevoValor); // si se quiere tener en cuenta el valor previo de resultado.

En este último caso el orden de ejecución de la expresión, sería: • crea una copia de la variable valorUno. • incrementa el valor de la variable valorUno (queda en 9.3). • al valor que hay en la copia, le resta el valor que tiene la variable nuevoValor (8.3 – 8) • toma la parte entera de este valor • el contenido de resultado se multiplica por el valor obtenido (1 * 0) • Al final valorUno = 9.3, nuevoValor = 8 - no fue modificado - y resultado = 0.

• int valorA = 3, valorC = 8, valorD = 4; boolean valorB; valorB = (valorA != valorC) || (valorD > valorA); ���� se están declarando tres variables de tipo entero - valorA, valorC, valorD - y una variable de tipo booleano. Se inicializan las tres variable enteras, la primera (valorA) con tres, la segunda (valorC) con 8 y la tercera (valorD) con 4. A la cuarta no se le asigna valor inicial. Después se plantea una expresión, que es correcta. La secuencia de ejecución del bloque, es: 1. Se crea la variable int valorA y se le asigna como valor inicial tres (3). 2. Se crea la variable entera valorC y se le asigna como valor inicial ocho (8).

18

3. Se crea la variable entera valorD, y se le asigna como valor inicial cuatro (4) 4. Se crea la variable booleana valorB, y no se le asigna valor inicial. 5. El orden de ejecución de esta expresión, sería: • compara, utilizando el operador diferente, valorA con valorC. • se obtiene true como respuesta. • como el operador es ||, no se evalúa la segunda parte de la expresión. • se asigna a valorB el valor true.

Ejercicios Propuestos. 1. ¿Qué se está haciendo en los siguientes casos? ¿Es correcto? ¿Qué valor devuelve?

• int valorA = 1, valorB = 5, valorC = 4, valorD = 0;

valorC = valorA++ * -- valorB;

valorD /= valorC;

boolean valorJ = valorD % valorA == 0 || valorC /valorD > 1;

• int valorA = 5, valorB = 10, valorC = 15;

int selección = valorA > valorB && valorA > valorC ? valorA : (valorB > valorC ?

valorB : valorC);

• double suma = 10.0, precio = 100;

suma += precio >= 100 ? precio * 1.1 : precio;

1.11 Tipos de Datos Referenciados.

1.11.1 Arreglos Los tipos de datos referenciados o compuestos son aquellos que pueden tener un grupo de valores asociados a ellos organizados mediante una estructura dada; entre estos tipos de datos encontramos los arreglos. Los arreglos son un conjunto finito de valores o referencias del mismo tipo. Esto permite organizar información que en otro caso sería muy difícil de manejar. Por ejemplo, suponga que se desean tener 100 números enteros, ¿será necesario crear 100 variables enteras para guardar estos números? Gracias a los arreglos no. Un arreglo es una estructura compuesta de varios elementos, todos del mismo tipo, almacenados en forma consecutiva. Cada elemento, se encuentra en una “celda”, las cuales se numeran desde 0 hasta la longitud del arreglo menos uno. Por ejemplo: Esta sería una posible representación de un arreglo llamado “datos”, que tiene 5 posiciones de enteros, es decir, puede guardar cinco valores enteros, cada uno en

23 5 -30 7 8

0 1 2 3 4

datos

19

una celda. En la posición cero de este arreglo se encuentra el número 23, y en la posición 4 del arreglo, la última, se encuentra el número 8. Dado que es posible saber qué elemento se encuentra en cada posición del arreglo, se dice que los arreglos son conjuntos ordenados. La forma de tener acceso a cada celda del arreglo, es a través de un índice, el cual indica el número de la celda, de la siguiente manera: datos[1] � hace referencia al valor entero que hay en la posición 1. // 5 Cada celda se comporta como una variable del tipo determinado por el arreglo, y por lo tanto puede cambiar su valor. Por ejemplo, para cambiar el valor que hay en la posición 3 del arreglo y guardar allí el valor –2, se haría algo así: datos[3] = -2; El arreglo quedaría: En java los arreglos se declaran de la siguiente forma: tipo nombre[ ]; ó: tipo[ ] nombre; Donde tipo es el tipo de los elementos que puede contener el arreglo y nombre es el identificador del mismo. Por ejemplo: • double reales[ ]; // está declarando un arreglo de dobles que se llama reales

• char[ ] letras; // está declarando un arreglo de caracteres llamado letras

Antes de que se pueda usar un arreglo, debe CREARSE, es decir, definir su tamaño para que java pueda reservar el espacio adecuado. El tamaño del arreglo, siempre, es un número entero y una vez definido no puede cambiarse. Siguiendo con los ejemplos presentados antes: • Se crea el arreglo reales, dándole como tamaño 10:

reales = new double [10]; /* Nótese que reales no lleva corchetes ([ ]), pues ya fue declarado.*/

• Se crea el arreglo letras, que es de caracteres. Quedará con las posiciones indicadas por el valor de la variable entera dimensión:

int dimensión = 5; letras = new char[dimensión];

23 5 -30 -2 8

0 1 2 3 4

datos

20

También puede unirse la declaración y la creación del arreglo en una sola instrucción, como se muestra a continuación:

int números[ ] = new int[10]; // declara y crea un arreglo de enteros de 10 posiciones.

Cuando se crea un arreglo en java se inicializan automáticamente todas sus posiciones, cosa que no sucede con las variables simples. Si el arreglo es de elementos numéricos se inicializan en cero (0), si es de caracteres se inicializa en el carácter nulo (‘\u0000’), si es booleano en false y si contiene otros tipos referenciados (como cadenas) se inicializan en null. Una vez creado el arreglo pueden utilizarse todos los valores que contiene, a través del nombre del arreglo y el índice, que es un número entero. A continuación se guardará el valor 5.2 en la primera posición del arreglo reales, y en la última posición se guardará este valor más 1.0

reales[0] = 5.2; reales[9] = reales[0] + 1.0

Los índices pueden ser cualquier valor entero, por ejemplo:

int posición = 0; posición+=1; reales[posición] = 4.6; // Guarda 4.6 en la posición 1 del arreglo reales.

Ejercicios Resueltos. • ¿Qué se está haciendo en los siguientes casos? ¿Es correcto?

• double arreglo = new double[5]; � No es correcto porque se está declarando una variable simple de tipo doble (llamada arreglo), y por lo tanto no puede contener un arreglo, de 5 posiciones, que contenga valores dobles.

• int[ ] valores = new int[3]; valores[0] = valores[2] + 5; int celda = 1; valores[celda] = 3; � Es correcto. Los pasos que se realizan son: • Se declara y se crea un arreglo de enteros de tres posiciones llamado valores. • A la primera posición del arreglo se le asigna lo que hay en la última posición del arreglo

más cinco. • Se declara una variable entera llamada celda y se le asigna un valor inicial de uno. • Se asigna tres a la segunda posición del arreglo.

• char otro[] = new char[8]; otro[-1] ���� No es correcto porque se está tratando de hacer referencia a una posición que no existe dentro del arreglo otro, pues este arreglo tiene posiciones de 0 a 7.

Ejercicios Propuestos. 1. ¿Qué se está haciendo en los siguientes casos? ¿Es correcto?

• byte[] miArreglo = new miArreglo[7];

miarreglo[5] = 3;

21

• int[] posiciones = new int[3];

double valores[] = new double[6];

posiciones[1] = 1;

posiciones[2] = 2;

valores[ posiciones[1] ] = posiciones[2] *3.0;

• boolean estados[] = new boolean[2];

estados[0] = true;

• int ejemplo[] = new int[23];

ejemplo = 3;

• Suponga que necesita guardar la información de los productos de un restaurante. Allí tienen cinco productos, y de cada uno se tiene su nombre y el valor. ¿En este problema, se pueden usar arreglos? Si es así, ¿cuántos arreglos necesitaría? ¿Cómo los declararía y crearía?

1.11.2 Clases que se encuentran en java.lang. En java la organización de las clases es similar a la de las carpetas que se emplean en el sistema operativo Windows, sólo que en java se denominan “paquetes”. Igual que en el sistema operativo una carpeta puede contener otra carpeta, en java un paquete puede estar ubicado dentro de otro paquete, sin que esto genere ningún inconveniente. Los paquetes básicos de java están en un gran paquete denominado java y dentro de este hay otros, el primero es el paquete lang. Este es el paquete que contiene las clases básicas para el funcionamiento del lenguaje; tanto así que sin él no podría ejecutarse ningún tipo de código, y contiene un gran número de clases pero, en la parte inicial del libro, se trabajará únicamente con String, y las clases Wrapper, y en la parte final del mismo (en el capítulo de Conceptos Básicos de Programación Orientada a Objetos), se incluirá la clase Object. 1.11.2.1 java.lang.String.

Cada objeto, o instancia, de esta clase contiene una secuencia de caracteres pertenecientes a la tabla Unicode. Esta secuencia puede tener la longitud que se requiera, es decir puede comprender desde una letra hasta un párrafo. Una de las mayores fortalezas de esta clase, son los métodos o servicios que ofrece a los programadores, y que resuelven operaciones básicas de trabajo con cadenas de caracteres. Estos métodos se presentarán más adelante. 1.11.2.2 Clases Wrappers.

22

Se trata de un grupo de clases que permiten “envolver” un tipo de dato básico en un objeto, para algún tratamiento particular. Existe una clase para cada tipo de dato básico, como se muestra a continuación:

Tipo de dato básico

Clase Wrapper

byte Byte short Short int Integer long Long float Float double Double boolean Boolean char Character

1.11.3 Clases que se encuentran en java.util.

En este paquete se encuentran las clases que los desarrolladores de java, han considerado que facilitan el trabajo de otros programadores, es decir este paquete contiene las clases que “facilitan” la vida al programador. En este capítulo sólo se revisarán las clases Scanner, Random, ArrayList y Arrays. Dado que las clases que están en este paquete no conforman la parte básica de java, siempre que se quiere usar alguna clase contenida en él, se debe “avisar” al compilador de java, para lo cual se debe usar una línea de código, antes de definir la clase, como se muestra a continuación: import java.util.*; // Esta es la línea que se debe incluir. public class Trabajo { // Esta es la línea en la cual se empieza a definir la clase. 1.11.3.1 Scanner.

Cada objeto de esta clase está en capacidad de ofrecer una serie de servicios que permiten obtener información de diversos medios como archivos o el teclado. Como tema de este libro sólo se estudiará la forma de obtener datos a través del teclado.

1.11.3.2 Random.

Cada objeto de esta clase está en capacidad de generar valores numéricos en forma seudo aleatoria. Entre más grande sea el rango entre el cual pueden variar estos valores, mayor probabilidad hay de obtener valores diversos; puesto que, cuando se trabaja con rangos pequeños, el objeto tiende a regresar el mismo valor o valores muy próximos.

1.11.3.3 ArrayList.

23

Cada objeto de esta clase permite guardar una colección de referencias a objetos de cualquier clase definida. Su comportamiento es similar al de un arreglo, sin embargo tiene la gran ventaja de que su tamaño puede crecer en forma ilimitada, a diferencia de los arreglos que tienen un tamaño que no puede ser modificado. Dado que un objeto de esta clase sólo contiene referencias a objetos, no a valores, las clases wrappers son muy útiles si se requiere guardar una cantidad no definida de valores. 1.11.3.4 Arrays.

Los arreglos, como se mencionó previamente, son tipos de datos referenciados, que no ofrecen ningún servicio especial, de hecho para conseguir su longitud se hace referencia a un atributo (length), no a un método. Sin embargo, existe una clase: java.util.Arrays, que presta una serie de servicios para facilitar el trabajo con los arreglos. 1.11.4 Métodos de las clases presentadas.

Para los tipos de datos referenciados no existen operaciones, sino que se definen métodos, los cuales permiten trabajar con estos datos en forma muy simple.

Los métodos tienen una forma estándar, tanto en la parte formal del análisis, como en la parte de elaboración del código; y aunque este tema será estudiado, a fondo, en la segunda parte del curso, a continuación se presenta la forma en el análisis, con una muy breve explicación:

Forma en el análisis:

+ nombreDelMétodo(parámetros): tipoQueDevuelve

nombreDelMétodo: permite identificar qué servicio se le pedirá al objeto que preste.

parámetros: es la información que requiere el método para poder prestar el servicio que se le pide que preste.

tipoQueDevuelve: indica qué se debe esperar que el objeto retorne, al terminar de prestar el servicio.

Algunos métodos de las clases presentadas:

1.11.4.1 String Para usar los métodos que ofrece esta clase, se requiere contar con un objeto que sea instancia de ella, y a él se le pide el servicio requerido.

String cadena = “¡ Hola Mundo !”;

• length(): int Este método retorna la longitud de la cadena de caracteres, por ello retorna un valor entero. No requiere parámetros.

int longitud = cadena.length(); /** al objeto referenciado por el identificador cadena, se le pide que de su longitud.

24

¿Qué valor quedaría en longitud? */

• charAt(int): char Este método retorna el carácter ubicado en la posición dada como parámetro. Tenga presente que java cuenta desde 0, y que si da un valor mayor al de la posición del último carácter, obtendrá un error.

char primero = cadena.charAt(0); /** al objeto referenciado por el identificador cadena, se le pide que retorne el carácter ubicado en la posición 0. Es decir en la variable primero quedaría ‘¡’, y el objeto al cual cadena hace referencia, no cambiaría.

¿Qué valor habría que dar como parámetro para obtener el carácter ‘!’?

*/

• equals(Object): boolean Este método compara la cadena a la que se le pide el servicio con la cadena que se le da como parámetro; retorna true si son iguales, y false en caso contrario.

String otra = “hola mundo”; boolean iguales = cadena.equals(otra); /** se le pide, a cadena, que diga si a lo que hace referencia es igual a lo que referencia otra. En este caso se obtendría falso, pues las dos cadenas de caracteres referenciadas son distintas.*/

• equalsIgnoreCase(String): boolean Este método compara la cadena a la que se le pide el servicio con la cadena que se le da como parámetro; pero, a diferencia del anterior, no hace diferencia entre mayúsculas y minúsculas.

String otra = “hola mundo”; boolean iguales = cadena.equalsIgnoreCase(otra); /** ocurre lo mismo que en el caso anterior, pero se ignoran las mayúsculas.

¿Qué valor quedaría en iguales? ¿Por qué?

*/

• toUpperCase(): String Se obtiene una nueva cadena, en la cual todas las letras contenidas en la cadena original, serán mayúsculas.

String cadena = “¡cambio de texto!”; String otra = cadena.toUpperCase(); /** en otra quedaría “¡CAMBIO DE TEXTO!”, observe que los caracteres que no son letras, no sufren ningún cambio.

¿Qué método sería apropiado usar para comparar si dicen lo mismo las dos cadenas? */

• toLowerCase(): String Se obtiene una nueva cadena, en la cual todas las letras contenidas en la cadena original, serán minúsculas.

String cadena = “5 en alemán se dice: ¡FÜNF!”;

25

String otra = cadena.toLowerCase(); /** en otra quedaría “5 en alemán se dice ¡fünf!”. Observe que se incluyen todas las letras en minúscula, aún si tienen diéresis o están tildadas. */

1.11.4.2 Integer – clase wrapper – Para esta clase se verán dos tipos de métodos: los que permiten crear objetos de ella – denominados constructores – y los que permiten obtener servicios de los objetos creados.

Constructores: String cadena = “5”; Integer primero = new Integer (cadena); /** crea una referencia a un nuevo objeto Integer, que contendrá el valor entero 5. Si la cadena que se da como parámetro contiene caracteres no numéricos se genera un error.

Pinte cómo quedaría la memoria después de ejecutar estas dos líneas de código. */ int valor = 33; Integer segundo = new Integer (valor); /** se crea una referencia a un nuevo objeto Integer, que contendrá el valor entero 33. */

Otros métodos:

• equals(Object): boolean Este método compara el objeto Integer al que se le pide el servicio con el que se da como parámetro; retorna true si son iguales, y false en caso contrario.

boolean iguales = primero.equals(segundo); /** se le pide al objeto al cual primero hace referencia que diga si es igual al objeto al cual hace referencia segundo.

¿Cuál cree que sería el resultado de esta operación?

*/

• compareTo(Integer): int Compara dos objetos Integer, retorna 0 si los objetos comparados son iguales, un valor negativo si el valor entero que contiene el objeto al cual se le pide que se compare es menor que el valor entero contenido por el objeto que se da como parámetro, en caso contrario retorna un valor positivo.

int primeraComparación = primero.compareTo(segundo); int segundaComparación = segundo.compareTo(primero); int diferencia = primeraComparación + segundaComparación; /**

¿Qué valor quedaría guardado en diferencia? ¿Por qué cree que obtuvo ese valor? Debe ser claro, que su respuesta debe estar basada en el resultado que obtuvo al probar esta porción de código

26

*/

• intValue(): int Este método retorna el valor entero que contiene el objeto referenciado.

int valor = primero.intValue(); /** En la variable valor quedaría 5: valor entero. */

• doubleValue(): int Este método retorna el valor entero que contiene el objeto referenciado, pero en formato real de precisión doble.

double otroValor = primero.doubleValue(); /** En la variable otroValor quedaría 5.0: valor real. */

• toString(): String Este método retorna el valor entero que contiene el objeto referenciado, pero en formato cadena de caracteres. Este método no necesita ser llamada, pues si se le pide a java que muestre un objeto, java invocará este método de manera automática.

System.out.println(segundo.toString()); System.out.println(segundo); /** Estas dos líneas de código producirían exactamente el mismo resultado en la consola: 33. */

Todas las otras clases de este grupo, es decir las que envuelven valores numéricos, ofrecen estos mismos métodos.

1.11.4.3 Boolean – clase wrapper – Para esta clase también se presentan los constructores y los métodos de servicio:

Constructores: String cadena = “true”; Boolean primero = new Boolean (cadena); /** se crea una referencia a un nuevo objeto Boolean, que contendrá el valor true. Si la cadena que se da como parámetro contiene caracteres que no corresponden a true ni a false, se generará un error. */ String otraCadena = “TRUE”; Boolean segundo = new Boolean (otraCadena); /** Es importante tener presente que este constructor ignora las mayúsculas, así que en segundo quedará una referencia a un objeto Boolean que contiene true. */

Otros métodos:

• equals(Object): boolean Este método compara el objeto Boolean al que se le pide el servicio con el que se da como parámetro; retorna true si son iguales, y false en caso contrario.

boolean iguales = primero.equals(segundo); /**

27

si se parte de que primero y segundo, contienen lo asignado en el ejemplo previo, ¿cuál sería el resultado que quedaría en iguales?

*/

• compareTo(Boolean): int Compara dos objetos Boolean, retorna 0 si son iguales, un valor negativo si al que se le pide el servicio contiene una referencia a un objeto que contiene false, y el otro contiene true; un valor positivo de lo contrario.

int comparación = primero.compareTo(segundo); /**

¿Qué valor quedaría guardado en comparación?

*/

• booleanValue(): int Este método retorna el valor boolean que contiene el objeto referenciado.

boolean valor = primero.booleanValue(); /** En la variable valor quedaría true */

• toString(): String Este método retorna el valor entero que contiene el objeto referenciado, pero en formato cadena de caracteres. Este método no necesita ser llamada, pues si se le pide a java que muestre un objeto, java invocará este método de manera automática.

System.out.println(segundo);/**

¿Qué se vería en pantalla? */

1.11.4.4 Scanner.

Para esta clase se presenta un constructor y algunos métodos que pueden prestar sus instancias:

Constructor: Scanner lector = new Scanner(System.in); /** se crea una referencia a un nuevo objeto Scanner, el cual está en capacidad de leer lo que llegue por el dispositivo estándar de entrada de datos – por omisión este dispositivo es el teclado –. */

Otros métodos:

• next(): String Este método permite leer una palabra. Debe tenerse presente que si el usuario digita algo más que una palabra antes de la tecla “Intro”, esto será ignorado.

28

• nextLine(): String Permiten leer la cadena de caracteres, que el usuario de su

clase ejecutable, esté digitando en el teclado. A diferencia del anterior, este método lee todo lo que el usuario digita, hasta que hunde la tecla “Intro”.

System.out.println(“Digite el nombre del usuario a registrar:” ); String nombre = lector.nextLine(); /** En nombre quedaría lo que el usuario digite como nombre del usuario a registrar. Debe tenerse presente que, para claridad por parte del usuario, debe incluirse un mensaje antes indicando qué tipo de valor se espera. */

• nextInt(): int nextDouble(): double nextBoolean(): boolean Estos métodos permiten leer lo que el usuario digita, y lo convierten al valor correspondiente, siempre que esto sea posible; si el usuario digita algo que no puede ser convertido al valor esperado, se generará un error. Debe tenerse presente que estos métodos sólo leen el tipo de dato mencionado en su nombre, así que ignoran el carácter que se genera cuando el usuario digita la techa “Intro” (‘\n’), y este carácter debe ser leído a través del método nextLine().

System.out.println(“Digite la edad del usuario a registrar:” ); int edad = lector.nextInt(); lector.nextLine(); /** La edad digitada quedaría en la variable edad, y esta última línea leería el cambio de línea (‘\n’), el cual no interesa guardar, por lo que no se asigna a ninguna variable. */

1.11.4.5 ArrayList.

Para esta clase, también, se presenta un constructor y los métodos que permiten obtener servicios de sus instancias.

Constructores: ArrayList lista = new ArrayList(); /** se crea una referencia a un nuevo objeto, el cual está en capacidad de contener un número ilimitado de referencias a cualquier tipo de objetos. */ Otros métodos:

• add(Object): boolean Este método adiciona una referencia al objeto pasado como parámetro, en la lista contenida en el ArrayList. Retorna un valor boolean indicando si pudo adicionarla o no, este valor casi siempre es ignorado.

int valor = 89; Integer primero = new Integer(valor); boolean ingresado = lista.add(primero); /** se adiciona una referencia al objeto al cual hace referencia primero, dentro de la lista.

¿Por qué cree que no se guardó, directamente, valor?

*/

29

• size(): int Este método retorna la cantidad de referencias que contiene la lista. int elementos = lista.size(); /** en elementos quedaría guardado 1, pues hasta el momento sólo se ha adicionado una referencia. */

• get(int): Object Este método retorna una nueva referencia al objeto, cuya referencia se encuentra en la posición dada como parámetro. Una vez más debe tenerse presente que java cuenta desde 0, y que si se da un valor mayor a la cantidad de referencias que contiene la lista se generará un error.

Integer unObjeto = lista.get(0); /**esta línea de código generaría un error, pues este método retorna un Object, no un Integer; por esto debe emplearse el cast. */ Integer unObjeto = (Integer) lista.get(0); /**en unObjeto quedaría una referencia al objeto Integer que se agregó a través del add.

De acuerdo a lo anterior, ¿qué valor quedaría en igualdad: boolean igualdad = unObjeto.equals(primero); */

• toArray(): Object[] Crea un arreglo, del mismo tamaño de la lista, el cual contiene las mismas referencias que el ArrayList.

Object[] arreglo = lista.toArray();

1.11.4.6 Arrays.

Como es la clase la que presta estos servicios, no un objeto como se ha visto hasta ahora, la forma de usar estos métodos cambia un poco:

Arrays.servicioAEmplear(parámetros): valorQueRetorna.

• equals(arregloUno, arregloDos): boolean Este método compara los contenidos los arreglos que se pasan como parámetros, y retorna true si son iguales y false en caso contrario. Los dos arreglos deben haber sido definidos como depósitos del mismo tipo de datos.

int[] primero = {1,2,3,4,5}; int[] segundo = new int[5]; segundo[0] = 1; segundo[1] = 2; segundo[2] = 3; segundo[3] = 4; segundo[4] = 5; boolean iguales = Arrays.equals(segundo,segundo); /** Retornaría true, pues los arreglos están definidos del mismo tipo, y contienen los mismos valores y en el mismo orden. */

• sort(arreglo): void Este método ordena, en forma ascendente, el arreglo que se da como parámetro. Debe tenerse presente que no crea un nuevo arreglo, con la información ordenada, sino que ordena la información en el mismo arreglo; es decir el arreglo desordenado se pierde. Por ahora debe usarse,

30

únicamente, con arreglos que contengan tipos básicos, o cadenas de caracteres.

double [] arreglo = {15.9, 21.8, 3.0, 4.3, 27.5}; Arrays.sort(arreglo); /** arreglo quedaría: [ 3.0 | 4.3 | 15.9 | 21.8 | 27.5 ] */ String[] nombres = { “Víctor”, “Amelia”, “Mauricio”, “Bernardo”, “Luisa”, “Carlos”, “Juanita”, “David”, “Hugo”}; Arrays.sort(nombres); /**

¿Cómo quedaría nombres? */

1.12 Diseño de medios interactivos

Ejercicios resueltos

Los siguientes ejercicios pueden ser ejecutados en Processing, han sido elaborados en la versión 0135, la última versión se puede descargar gratuitamente desde http://processing.org.

1.12.1 Ejercicios sobre operaciones básicas

1.12.1.1 ¿Dónde se ubicarían? /* Ubicar puntos - operaciones básicas ¿Dónde se ubicarían los 5 puntos que son dibujados por el siguiente código? - Considere cada operación de forma independiente de las predecesoras. Autor: Juan Carlos Muñoz - Marzo 2008 Para: Fundamentos de programación para el diseño - Universidad Icesi Descripción: Las coordenadas de cada uno de los puntos, se pueden ver en la consola (en la parte inferior de la pantalla). Esta salida es producida por el llamado al método println. */

Código // Se definen las variable para almacenar las posiciones en X y Y // para dibujar los puntos int puntoInicialX, puntoInicialY; // Se define el grosor de los elementos que se van a dibujar strokeWeight(3.0); // 1. Se modifican las posiciones iniciales de acuerdo a las variables // establecidas, recuerde: de la división entre enteros, solo se toma // la parte entera puntoInicialX=5/3+40; puntoInicialY=4+60/3+35; // Se dibuja nuevamente el punto en las posiciones modificadas (41,59), point(puntoInicialX,puntoInicialY); println(puntoInicialX+" "+puntoInicialY); // 2. Se modifican las posiciones iniciales nuevamente, de la división // solo se toma la parte entera puntoInicialX=5+30%4*22; puntoInicialY+=(4+55)-13* 5+25; // Se dibuja nuevamente el punto en las posiciones modificadas (14,40) point(puntoInicialX,puntoInicialY);

Resultado obtenido

31

println(puntoInicialX+" "+puntoInicialY);

// 3. Se modifican las posiciones iniciales nuevamente, de la división // solo se toma la parte entera puntoInicialX=5; puntoInicialX= puntoInicialX++ * puntoInicialX - 1; puntoInicialY= 80-5 /4; // 4. Se dibuja nuevamente el punto en las posiciones modificadas (5,55) point(puntoInicialX,puntoInicialY); println(puntoInicialX+" "+puntoInicialY); puntoInicialX=5<4?4*5:4+5; puntoInicialY=4<3||3<4?10:15; // Se dibuja nuevamente el punto en las posiciones modificadas (2,70) point(puntoInicialX,puntoInicialY); println(puntoInicialX+" "+puntoInicialY);

1.12.2 Manejo de coordenadas

1.12.2.1 Dibujo de puntos

/* Puntos - manejo de coordenadas Dibujo de líneas a partir de variables globales variables globales Autor: Juan Carlos Muñoz - Febrero 2008 Para: Fundamentos de programación para el diseño - Universidad Icesi */

Código int posInicialX=15, posInicialY=25; int separacionX=70, separacionY=50; point(posInicialX,posInicialY); point(posInicialX+separacionX,posInicialY); point(posInicialX+separacionX, posInicialY+separacionY); point(posInicialX, posInicialY+separacionY);

Resultado obtenido

1.12.2.2 Dibujo de cuadrado a partir de líneas /* Cuadrado por partes - manejo de coordenadas Dibujo de cuadrado con líneas a partir de variables globales Autor: Juan Carlos Muñoz - Febrero 2008 Para: Fundamentos de programación para el diseño - Universidad Icesi */

Código

int posInicialX = 15, posInicialY = 25; int ancho = 70, alto = 50; line(posInicialX,posInicialY, posInicialX+ancho, posInicialY); line(posInicialX+ancho,posInicialY,posInicialX+ancho,posInicialY+alto); line(posInicialX,posInicialY+alto,posInicialX+ancho, posInicialY+alto); line(posInicialX,posInicialY, posInicialX, posInicialY+alto);

Resultado obtenido

1.12.2.3 Dibujo de rectángulos con incremento /* Rectángulos concéntricos - manejo de coordenadas

32

Dibujo de rectángulos con incremento a partir de variables globales Autor: Juan Carlos Muñoz - Febrero 2008 Para: Fundamentos de programación para el diseño - Universidad Icesi */

Código int posInicialX = 25, posInicialY = 35; int anchoInicial = 50, altoInicial = 30; int pasoIncremento = 5, incremento = 0; noFill(); rect(posInicialX-incremento,posInicialY-incremento, anchoInicial+incremento*2,altoInicial+incremento*2); incremento += pasoIncremento; rect(posInicialX-incremento,posInicialY-incremento, anchoInicial+incremento*2,altoInicial+incremento*2); incremento += pasoIncremento; rect(posInicialX-incremento,posInicialY-incremento, anchoInicial+incremento*2,altoInicial+incremento*2); incremento += pasoIncremento; rect(posInicialX-incremento,posInicialY-incremento, anchoInicial+incremento*2,altoInicial+incremento*2); incremento += pasoIncremento; rect(posInicialX-incremento,posInicialY-incremento, anchoInicial+incremento*2,altoInicial+incremento*2);

Resultado obtenido

1.12.3 Figuras básicas

1.12.3.1 Dibujo con escala de elipses, triángulos y rectángulos /* Cara cuadrada - figuras básicas Muestra como dibujas las figuras básicas Autor: Juan Carlos Muñoz - Marzo 2008 Para: Fundamentos de programación para el diseño - Universidad Icesi Descripción: Para cada figura o conjunto de figuras se deben definir las posiciones a partir de las cuales se van a dibujar y de ser necesario la escala. El modificar estas variables afecta todas las figuras pero conserva la composición. */

Código int posIniX = 50, posIniY = 25; // Modifique el valor de la escala en un número // entre 0 y 2 para observar como se mantiene la // relación entre elementos float escala = 1; size(200,200); // Dibuja un rectángulo, recibe las posiciones // iniciales y el ancho y alto rect (posIniX,posIniY,100*escala,20*escala); // Dibuja una elipse, recibe las posiciones centrales // y el ancho y alto ellipse(posIniX+15*escala,posIniY+50*escala,15*escala, 15*escala); ellipse(posIniX+(100-15)*escala,posIniY+50*escala, 15*escala,15 * escala); // Dibuja un triángulo, recibe las posiciones de // los tres puntos triangle(posIniX+50*escala,posIniY+60*escala, posIniX+65*escala,posIniY+75*escala, posIniX+35*escala,posIniY+75*escala); // Dibuja un rectángulo, recibe las posiciones // iniciales y el ancho y alto

Resultado obtenido

33

rect (posIniX,posIniY+100*escala,100*escala,20*escala);

1.12.3.2 Dibujo con coordenadas relativas de arcos y líneas /* Dibujos simples - figuras básicas Dibujo de figura uniendo líneas y arcos Autor: Juan Carlos Muñoz - Marzo 2008 Para: Fundamentos de programación para el diseño - Universidad Icesi */

Código int posIniX = 75, posIniY = 30; size(200,200); noFill(); arc (posIniX+20,posIniY+20, 40, 40,PI,TWO_PI-PI/2); arc (posIniX+20,posIniY+20, 40, 40,TWO_PI-PI/2,TWO_PI); line (posIniX, posIniY + 20, posIniX - 20, posIniY + 90); line (posIniX+40, posIniY+20, posIniX+60, posIniY+90); arc (posIniX+5, posIniY+90, 50, 30, PI/2, PI); arc (posIniX+35, posIniY+90, 50, 30, 0, PI/2); line(posIniX+5, posIniY+105, posIniX+35, posIniY+105);

Resultado obtenido

1.12.4 Color básico

1.12.4.1 Definición de color como literal y variable /* Escala de grises - color básico Este ejemplo muestra como cambiar el color de las líneas y relleno de las figuras. Revise cada fragmento de forma independiente. Autor: Juan Carlos Muñoz - Marzo 2008 Para: Fundamentos de programación para el diseño - Universidad Icesi */

Código //Define el tamaño del lienzo size(200,200); //Define el grosor de las líneas strokeWeight(3); // Dibuja un rectángulo por los valores por defecto rect (50,30,100,30); // Dibuja un rectángulo con borde gris // (0 => negro, 255 => blanco) stroke(150); rect (50,70,100,30); // Dibuja un rectángulo con borde gris y relleno negro fill(0); stroke(150); rect (50,110,100,30); // Dibuja un rectángulo sin borde y relleno negro noStroke(); fill(0); rect (50,150,100,30);

Resultado obtenido

34

1.12.4.2 Cambio programático del color

/* Escala de grises 2 - color básico Este ejemplo muestra como cambiar el valor del color por medio de variables Autor: Juan Carlos Muñoz - Marzo 2008 Para: Fundamentos de programación para el diseño - Universidad Icesi */

Código // Cualquier valor entre 0 y 255 int colorCuadro = 100, colorLinea = 200; //Define el tamaño del lienzo size(200,200); //Define el grosor de las líneas strokeWeight(3); // Dibuja un rectángulo estableciendo primero el color de la // línea y el relleno. fill(colorCuadro); stroke(colorLinea); rect (50,30,100,30); // Modifica los valores de color de la linea y el relleno colorCuadro += 20; colorLinea -= 50; // Dibuja un rectángulo con los nuevos valores // (0 => negro, 255 => blanco) fill(colorCuadro); stroke(colorLinea); rect (50,70,100,30); // Modifica de nuevo los valores de color de la línea // y el relleno colorCuadro += 30; colorLinea -= 30; // Dibuja un rectángulo con los nuevos valores fill(colorCuadro); stroke(colorLinea); rect (50,110,100,30); // Modifica de nuevo los valores de color de la línea // y el relleno colorCuadro += 50; colorLinea -= 20; // Dibuja un rectángulo con los nuevos valores stroke(colorLinea); fill(colorCuadro); rect (50,150,100,30);

Resultado obtenido

1.12.5 Polígonos

1.12.5.1 Formas de dibujar figuras con líneas /* Sin título - polígonos Este ejemplo muestra algunas forma de dibujar polígonos Autor: Juan Carlos Muñoz - Marzo 2008 Para: Fundamentos de programación para el diseño Universidad Icesi */

Código size(200,200); // Dibuja un rectángulo, uniendo los puntos beginShape();

Resultado obtenido

35

vertex(50, 20); vertex(150, 20); vertex(150, 55); vertex(50, 55); endShape(CLOSE); // Dibuja triángulos cada tres puntos beginShape(TRIANGLES); vertex(75, 75); vertex(90, 100); vertex(60, 100); vertex(125, 75); vertex(110, 100); vertex(140, 100); endShape(); // Dibuja triángulos con un punto común a todos beginShape(TRIANGLE_FAN); vertex(100, 110); vertex(50, 170); vertex(70, 170); vertex(90, 170); vertex(110, 170); vertex(130, 170); vertex(150, 170); vertex(100, 110); endShape(CLOSE);

Ejercicios propuestos

Los siguientes ejercicios se proponen para ser realizados en Processing.

1. Manejo de coordenadas: Diseñe sobre papel milimetrado un dibujo que pueda trabajarse exclusivamente a partir de puntos y líneas. Establezca una escala para relacionar las coordenadas sobre el papel y los pixeles de un lienzo de 300x300. Utilizando los métodos point y line realice el diseño en java utilizando Processing.

2. Color básico: Realice una geometrización sencilla en papel milimetrado en la cual utilice diferentes tonalidades de gris para las líneas o el relleno de las áreas. Utilice los elementos vistos hasta ahora, a saber, arcos, elipses, rectángulos, triángulos, líneas y puntos. A partir de la geometrización escale y escriba el código en java utilizando Processing.

3. Polígonos:

Realice la geometrización de una cámara fotográfica utilizando, adicional a los elementos básicos, los métodos beginShape, vertex y endShape para incluir polígonos en su diseño.