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 precedencia
3
, 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.