Inacap - Introducción A Lenguajes Formales de Programación PDF

65
UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

66
Introducción a lenguajes
formales de Programación.
Estructura de un programa.
En JAVA al igual que en la mayoría de los lenguajes de
programación orientados a objetos, el código se
estructura en clases, la forma básica de estructurar una
clase es la siguiente:
Los Atributos que representarán un objeto, por ejemplo,

para una persona los atributos pueden ser, su edad y
peso entre otros, los atributos de una clase están
representados por la declaración de estructuras y tipo
primitivos, para este caso por ejemplo, la edad puede
estar representada por un tipo de dato int (entero) y un
float respetivamente.
Accesadores y mutadores, los cuales son

comportamientos especiales dentro de una clase que
permiten conocer y cambiar el valor de un atributo.
Los comportamientos que un objeto tendrá, por ejemplo,

para nuestra persona, algunos ejemplos son correr y
jugar.

67
Sentencia condicionales
Las sentencias condicionales representan un punto en
nuestro programa donde el flujo del proceso cambiará
dependiendo de alguna condición. Si haces un análisis
simple verás que esto no es tan complicado de
comprender como se lee, la vida a diario esta lleno de
condiciones, las cuales vamos resolviendo día a día y esto
provoca que nuestro diario vivir sea incierto, siempre hay
una condición para todo, por ejemplo, dependiendo si vas
o no atrasado decidirás si ir a estudiar en metro o bus,
dependiendo de qué día es, la hora a la que te
levantarás. Este proceso mental es tan rápido que apenas
nos habíamos dado cuenta que lo realizamos tantas
veces al día. Si a cada una de estas situaciones que nos
enfrentamos a diario nos detuviéramos un momento y
nos analizáramos de qué depende que vayamos hacer
algo, nos daríamos cuenta que programar es muy similar,
por ejemplo, imagina que alguien te ofrece bebida y
antes responder en voz alta expresas la condición que te
llevará a determinar si aceptas o no, si lo haces muy
probablemente dirás algo similar a “¿tengo sed?” y si la
respuesta es verdadera entonces lo harás.
Una condición esta antecedida de la conjunción si (sin

acento). Podemos hacer uso de ella entonces para
formular todas aquellas condiciones a la que nos
enfrentamos a diario, algunos ejemplos son:
Si mi amigo va, yo voy.
Si estoy aburrido jugaré PC.

68
Si me han enseñado algo nuevo lo reforzaré.
Fíjate que en cada una de las frases anteriores hay una

acción que va a realizarse dependiendo de la condición
expresada en el sí, además debes notar que si bien no
esta escrito explícitamente también estamos diciendo que
si la condición no se cumple hay algo que dejaré de
hacer.
En informática este comportamiento es exactamente

igual, salvo por la forma en la que se escribe. Recuerda
que para comunicarnos con el computador debemos usar
algún lenguaje de programación y los lenguajes que más
se utilizan en el mercado están en inglés, así que
comenzaremos a dar nuestro primer gran paso en el
mundo de las condiciones, cambiaremos la conjunción si,
por la palabra clave if.
if mi amigo va, yo voy.
if estoy aburrido jugaré PC.
if me han enseñado algo nuevo lo reforzaré.
Bien, ya nos vamos acercando a nuestra meta y de lo

anterior podemos afirmar entonces que la palabra if debe
siempre ir acompañada de una condición la cual también
debemos representar de una forma que el computador
pueda entender. Supongamos ahora que para ir de paseo
con tus amistades hoy necesitas cancelar una cuota de
$10.000, en ese caso la condición debemos expresarla de
la siguiente forma:

69
if (plata >= 10000)
Donde plata es una variable que contiene algún valor el

cual podrá ser mayor, menor o igual a $10.000, no
importa el valor que esta tenga , siempre una sentencia
condicional de este tipo tendrá dos posibles resultados,
en el primer caso se cumple la condición y en el
segundo la condición no se cumple .El resultado de la
condición siempre determina si hay o no hay que hacer
algo, en este caso por ejemplo si el valor de la variable
plata es mayor o igual 10.000, entonces saldremos de
paseo, de lo contrario podemos tomar dos acciones
posibles, no hacer nada o buscar una actividad donde no
necesitemos esa cifra de dinero. Adicionalmente tal y
como lo muestra el ejemplo la condición debe ir entre
paréntesis.
Supongamos ahora que si la condición se cumple

entonces podremos salir de paseo lo que provoca un
incremento de uno en la variable diversión, en este caso
el if será presentado de la siguiente forma:
if(plata >= 10000)

{
diversion++;
}
Como puedes ver justo debajo de la condición el

incremento de la variable diversion se encuentra entre
un inicio de bloque “{“ y un cierre de bloque “}”. Estos

70
bloques delimitan el alcance de la condición, es decir

entre ellos debes escribir todo lo que sucederá si la
condición resulta ser verdadera. Observa ahora lo que
sucede si existen sentencias de código que se encuentran
fuera del inicio y cierre de bloque:
if(plata >= 10000)

{
diversion++;
}
tiempo++;
en este caso tenemos dos incrementos, el de la variable

diversion y el de la variable tiempo, sin embargo sólo
una de ellas está condicionada a la cantidad de dinero
que tengamos, dado que está encerrada entre los
bloques. Este extracto de código tiene entonces dos
posibles ejecuciones, el primero corresponde a cuando la
condición es verdadera, sólo si esto ocurre la variable
diversión hará su incremento, sin embargo la variable
tiempo no se encuentra dentro del alcance de la
condición y por ello hará su incremento ya que no
depende de nada, el flujo contrario entonces hará que
diversión no incremente su valor pero si lo hará la
variable tiempo.
Hasta ahora hemos visto como debiese comportarse el

código cuando la condición es verdadera, pero muchas
veces también nos gustaría definir un comportamiento
para cuando esta es falsa, o dicho de otra forma
definiremos el comportamiento de la condición para el

71
caso “sino es verdadera”. Para ello utilizaremos la

palabra reservada else (sino en inglés) la cual nos
permitirá delimitar todas aquellas acciones que deben
llevarse a cabo cuando la condición no se cumple,
veámoslo con un ejemplo, en el caso anterior cuando
disponíamos del dinero para salir entonces la diversión
tenia un incremento, pues ahora supongamos que sino
logramos salir entonces la diversión disminuye en uno,
para ello escribiremos lo siguiente:
if(plata >= 10000)

{
diversion++;
}
else
{
diversion--;
}
Como puedes ver en el caso anterior si la condición no se

cumple todo el código que se encuentre entre los
primeros bloques no se ejecutará, dando paso a ejecutar
todo lo que se encuentre dentro del else, realizando
entonces el decremento de la variable. Volvamos ahora a
agregar la variable tiempo, para que veas donde debe ir
ubicada:

72
if(plata >= 10000)

{
diversion++;
}
else
{
diversion--;
}
tiempo++;
Al igual que el caso anterior la variable tiempo esta luego

del if, por lo que su ejecución no esta condicionada ni al
caso verdadero ni al falso, por ello al igual que en el caso
anterior esta variable hará su incremento sin excepción,
sin embargo la variable diversión en cambio tendrá un
incremento o decremento en su valor sin escapatoria
pero nunca ambas.
La mayoría de las veces, el cumplimiento o no de una

condición requiere ejecutar más de una sentencia de
código, en ese caso bastará con agregar dentro de los
bloques tanto del if como todo else todas las que
desees, por ejemplo supongamos que si el dinero alcanza
no sólo incrementa la diversión, si no que también
descansas y que por otro lado si no alcanza el dinero para
el paseo no solo te aburres, si no que además incrementa
tu estrés.

73
if(plata >= 10000)

{
diversion++;
descanso++;
}
else
{
diversion--;
estres++;
}
tiempo++;
Así como muestra el ejemplo puedes agregar todas las

instrucciones que desees en cualquiera de los bloques,
por supuesto la cantidad de cada uno no debe ser igual,
lo importante es que por claridad siempre escribas
alguno, por ejemplo:
if(plata >= 10000)

{
}
else
{
diversion--;
}
Aquí lo que tratamos de hacer es establecer sólo el caso

del else diciendo que si el valor de la variable plata no es
mayor o igual a $10.000 se decrementa el dinero, pero si
es mayor o igual no pasa nada. Este caso puede ser

74
escrito de forma mucho más clara cambiando la condición

de la siguiente forma:
if(plata < 10000)

{
diversión--;
}
Dado que sólo else nos interesaba entonces ahora
cambiamos la condición y en vez de preguntar si el valor
de la variable plata es mayor o igual a $10.000
preguntamos lo contrario, es decir si el valor es menor,
de esta forma decimos que si esto se cumple entonces se
decrementa la diversión quedando mucho más fácil de
leer.
Veamos ahora un caso un poco más complejo, no

siempre tenemos la suerte de que una acción que
deseamos ejecutar dependa de una sola condición por
ejemplo, para salir de paseo tal vez necesites que el
dinero alcance, pero adicionalmente que la temperatura
se encuentre sobre los 17 grados, en este caso ambas
condiciones deben cumplirse y por ende deben
compararse con el operador lógico Y, el cual debe
simbolizarse con &&.
if(plata >= 10000 && temperatura >17)

{
diversion++;
descanso++;
}

75
En este caso para que se incremente diversión y

descanso ambas condiciones deben ser verdaderas.
Veamos otro ejemplo, supongamos ahora que no deseas

pasear sólo y para ir basta con que a cualquiera de tus
mejores amigos les alcance el dinero para ir. En este caso
la condición utilizada es O, dado que si el dinero
requerido lo posee cualquiera de ellos nosotros también
asistiremos al paseo (la condición es verdadera).
if(plataAmigo1 >= 10000 || plataAmigo2>= 10000)

{
diversion++;
descanso++;
}
Utilizamos entonces || para representar la condición O,

en este caso bastará que el valor en dinero de cualquiera
de ellos (o ambas) supere el valor de $10.000.
Anidada.
Las condiciones anidadas son condiciones que encuentras
de forma muy habitual en la vida diaria, en muchas
ocasiones una condición depende de otra, continuemos
pensando que saldremos de paseo y aún nuestra
limitante es el valor de la cuota y la temperatura, pero si
vamos de paseo aún nos queda dilucidar si iremos en
clase Premium o normal y ello dependerá del dinero que
tengamos, ya sabemos que es igual o mayor a $10.000 y

76
asumamos que si llevamos sobre los $15.000 podemos

darnos el gusto de viajar en Premium y gastar los $7.000
que vale el pasaje, de lo contrario pagaremos los $2.000
que cuesta el pasaje normal. Esta condición tiene sentido
sólo si se ha cumplido la primera, es decir sólo si la
temperatura es mayor a 17 y el dinero es igual o mayor a
los $10.000, de ninguna forma tiene validez pensarlo al
revés.
if(plata >= 10000 && temperatura >17)

{
diversion++;
descanso++;
if(plata >= 15000)

{
descanso++;
plata = plata – 7000;
}
else
{
plata = plata-2000;
}
}
else
{
diversion--;}

77
En el código anterior si la condición que nos va a permitir

salir de paseo se cumple, nuevamente incrementará la
diversión y el descanso, pero adicionalmente nos lleva a
otra condición, la cual nos permite saber, basándose en
el dinero obtenido, cuanto pagaremos por el pasaje. Si el
valor es superior o igual a $15.000 se restará de la
variable plata $7.000 pesos e incrementará el descanso
dada la comodidad que esto otorga, de lo contrario
descontará $2.000. Este tipo de if anidados (uno dentro
de otro) no tienen limitantes, vale decir puedes agregar
una dentro de otra tantas estructuras de condición sea
necesario, ya sea para el caso verdadero a para el falso.
Este tipo de if son utilizados cuando necesites evaluar
una condición que depende de una o más condiciones
previas.
Múltiple
En otras ocasiones no todo depende de una condición con
un resultado verdadero o falso. Un buen ejemplo es
simular el comportamiento felicidad que un alumno tiene
según la nota que ha obtenido, convengamos que la
felicidad es mayor mientras más alta la nota que
obtenga, supondremos que las notas que un alumno
puede obtener son C, B, A siendo C la nota más baja y A
la más alta. Para calcular la felicidad diremos que si ha
sacado una C el valor de la felicidad se multiplicará por 1,
si es B por 3 y si es A por 5. Para lograr esto necesitamos
conocer la nota preguntando si es A, si no lo es habría

78
que evaluar si es B o C, la forma de realizar esto es

utilizando varios if, lo que podría volverse muy tedioso si
las notas fuesen desde la A hasta la F, sin embargo (y
para suerte nuestra) existe una estructura condicional
llamada switch que nos permitirá definir varios flujos
según el valor de una variable, de esta forma
programaremos todas las acciones que deseemos
ejecutar para cualquiera de sus valores.
switch (nota)
{
case ’a’: felicidad*5;
break;
case ’b’: felicidad*3;
break;
case ’c’: felicidad*1;
break;
}
en el ejemplo anterior le pedimos a switch que evalué el

valor de nota y definimos varios casos. Fíjate que cada
caso esta compuesto por la palabra case y a su derecha
el valor que esperamos tenga la variable evaluada, si es
‘a’ ejecutará todo lo que venga luego del signo : (dos
puntos). En este caso multiplicará la felicidad*5 y hará un
break, el break es importante y significa corte o quiebre,
la utilidad que presta es de cortar la ejecución del switch,
dado que si el valor es “a”, no tiene mucho sentido
verificar si es “b” o “c”. Al igual que en if si la condición
se cumple puedes agregar cuantas sentencias desees

79
ejecutar, supongamos que si sacas una C tu animo decae

temporalmente en 1.
switch (nota)
{
case ’a’: felicidad*5;
break;
case ’b’: felicidad*3;
break;
case ’c’:
{
felicidad*1;
animo--;
}
break;
}
Sentencias de ciclo iterativo

Los ciclos permiten que una o más sentencias de código
se repitan hasta que una condición deje de cumplirse, es
muy similar a lo que sucede con un conductor de la
formula uno, el cual estará dando vueltas hasta que la
cantidad de vueltas que ha dado deje de ser insuficientes
para ganar la carrera, dicho en un lenguaje más
informático si la cantidad de vueltas que debe dar el
vehículo son diez, podremos expresarlo como mientras
la cantidad de vueltas sea menor a 10, entonces debe
seguir corriendo, pues en informática eso se expresa tal

80
cual como lo hemos mencionado. Veamos un ejemplo de

uno de los ciclos más utilizados, el cual recibe como
nombre el ciclo “mientras” al que de ahora en adelante
lo conoceremos por su traducción al inglés while.
While
while(vuelta<10)
{
vuelta++;
}
tiempo++;
Aquí la ejecución ocurrirá de la siguiente forma, lo

primero que hará while será evaluar si el valor de la
variable vuelta es o no menor a 10, si el valor fuese por
ejemplo 11, la condición no se cumplirá y para este caso
se comportará muy similar al if dejando de ejecutar todo
lo que se encuentre entre el inicio y cierre de bloques de
manera que la variable vuelta no se incremente, sin
embargo si el valor es 8, la condición será verdadera lo
que provocará que si se ejecute todo lo que esta dentro
de los bloques haciendo entonces el incremento de la
variable. Cuando haya finalizado el incremento el while a
diferencia del if no pasará directo a incrementar el
tiempo, dado que cuando alcance el cierre de bloque
volverá a preguntar por el valor de vuelta, el cual será 9
y dado que 9 aún es menor que 10 entonces while
volverá a ejecutarse, incrementando el valor de vuelta en
uno, al llegar al final de bloque nuevamente se va a

81
evaluar si vuelta es menor a 10, esta vez la condición no

se cumple y es entonces cuando el ciclo termina para dar
paso al incremento del tiempo.
For
Existen varias estructuras que permiten iterar una o más
líneas de código, el ciclo for es uno de ellos, pero antes
de continuar, es importante aclarar que si bien entre ellos
existen diferencias todos tienen el mismo objetivo, por
ende no existirá nunca una limitante para uno u otro,
pudiendo utilizar cualquiera de ellos cuando necesites
iterar, sin embargo cada uno tiene una estructura y
sintaxis diferente, el criterio de selección estará dado
principalmente por el que te acomode más y de las
necesidades que tengas.
Volvamos al ejemplo de las vueltas en una pista de

carreras presentada anteriormente. En aquel ejemplo el
while tiene por misión cerciorarse de que la variable
vuelta llegue a 10, pero no se preocupa del valor inicial
de la variable, supongamos que las condiciones cambian
y debes realizar el mismo algoritmo pero la variable
vuelta debe comenzar siempre en cero.
int vuelta=0;
while(vuelta<10)
{
vuelta++;
}
tiempo++;

82
El ciclo while cumple a la perfección con nuestro

propósito, sin embargo en el algoritmo hay 3 elementos a
considerar: primero hay una inicialización se variable, la
cual hemos agregado recientemente al solicitar que
vuelta siempre comience en cero, luego tenemos una
condición y un incremento, para este tipo de casos el for
es principalmente provechoso dado que permite escribir
de forma muy cómoda estos tres elementos. Veamos
como luce este while convertido en un cliclo for.
for(int vuelta=0; vuelta<10;vuelta++)

{
}
tiempo++;
Como puedes ver este ciclo contiene los tres elementos

como parte de la declaración del ciclo, por ende el cuerpo
de este ha quedado vacío, ya que hemos cambiado la
lógica de incremento de la variable a otro lugar. La forma
de ejecutarse no es igual que en while, para que lo
entendamos mejor vamos a decir que el for está dividido
en partes, la primera es una declaración, en la cual
declaramos e inicializamos el valor de la variable vuelta,
la segunda es la condición en la que decimos que vuelta
no debe ser mayor a 10 y finalmente una sección donde
incrementamos el valor de la variable vuelta en uno,
entonces podemos decir que las partes son, declaración
e inicialización, condición e incremento, entonces la
forma en la que el ciclo for funciona es la siguiente: lo
primero que ocurre es la declaración e inicialización, con
esto se asegura de que la variable exista y tenga un valor

83
inicial. Esta sección sólo se ejecuta una vez, el siguiente

paso es verificar si luego de la inicialización de la variable
la condición se cumple, de cumplirse ejecutará todo lo
que este entre los inicios y cierre de bloques, el cual
tenemos vacío por ahora. Al igual que el while el for
intentará hacer una iteración, pero sólo a partir de la
segunda vuelta y hasta que termine lo que hará es
primero ejecutar la sección de incremento, haciendo que
vuelta pase de cero a uno para luego verificar si la
condición aún se cumple. De cumplirse volverá a
ejecutar todo lo que se encuentre entre el inicio y cierre
de bloques, al finalizar nuevamente hará el incremento
y luego evaluará la condición. Este proceso se repetirá
hasta que la condición ya no se cumpla, como puedes ver
la responsabilidad de inicializar, evaluar e incrementar
esta toda definida dentro del for quedando entonces
tiempo para preocuparse de otros elementos dentro del
ciclo en sí, por ejemplo, contemos la cantidad de bencina
que gasta por cada vuelta almacenándola en una variable
llamada consumo.
int consumoPorVuelta = 0;
for(int vuelta=0; vuelta<10;vuelta++)
{
consumo += consumoPorVuelta;
}
tiempo++;
el ciclo for se puede adaptar a varias situaciones gracias

a que cualquiera de sus partes puede ser omitida, en el

84
siguiente ejemplo la declaración e inicialización de la

variable es quitada del for y declarada antes.
int vuelta=0;
for(; vuelta<10;vuelta++)
{
}
Así podemos entonces obtener un for cuyo

comportamiento es idéntico al de un while.
int vuelta=0;
for(; vuelta<10;)
{
vuelta++;
}
En este caso este for ha quedado exactamente como el

ciclo while que vimos en un comienzo. Podrá parecer
extraño pero incluso la condición puede ser omitida, sin
embargo eso nos obliga a tener que agregar a nosotros
una forma de quebrar el ciclo para que no este iterando
de forma indefinida. Sobre los quiebres de ciclos
hablaremos más adelante en la sección de break y
continues, pero por ahora como demostración de que
todas las partes son opcionales lo haremos analizando el
siguiente ejemplo:

85
for(; ; ;)
{
}
En este extraño caso no hay ninguna de las partes, sin

embargo la forma en la que se ejecutará no es ningún
misterio, ya que la ausencia de una condición da por
defecto falso, así que luego de comprobar que no hay
nada que inicializar, evaluará falso y omitirá la ejecución
del ciclo for.
Do … While.
Si del ciclo do while traducimos la palabra do veremos
que significa “hacer”, pues esta es la principal diferencia
con el ciclo while que vimos en una primera oportunidad,
la condición es evaluada al final, es decir que toda la
lógica agregada entre los inicios y cierres de bloque se
ejecutará siempre al menos una vez. Supongamos ahora
que el vehículo de carreras debe dar 10 vueltas seguidas
para hacer reconocimiento de la pista de forma
obligatoria, pero si ya ha dado 10 entonces sólo se le
permitirá dar una.
do
{
vuelta++;
}
while(vuelta<10);
Como puedes ver la condición se encuentra al final, por lo

tanto lo primero que sucederá es incrementar el número

86
de vueltas en uno, sin ninguna condición que pueda

evitarlo. Supongamos que el valor de la variable acaba de
incrementarse a 8, por lo tanto el corredor debe de forma
obligatoria completar sus 10 vueltas, dado que 8 es
menor a 10 la condición se hace verdadera dando paso a
una nueva ejecución del bloque incrementando el valor
de la variable a 9, con este valor la condición vuelve a
evaluarse siendo verdadera dado que aún es menor a 10,
en su última iteración la variable se incrementa a 10 y la
condición se vuelve falsa, saliendo así del ciclo, sin
embargo la diferencia está dada en que si vuelves a
ejecutar este ciclo con un valor de 10 o superior, con un
while el vehículo no hubiese sido aceptado, sin embargo
con este ciclo no se evalúa la cantidad de vueltas al
comienzo, por lo que las sentencias de código se
ejecutarán haciendo que vuelta sea 11, luego de la
primera ejecución el ciclo evaluará si debe proseguir,
como la condición es falsa, el vehículo no dará una
segunda vuelta.
Concepto de función
Una función representa una porción de código (un

conjunto de sentencias) que tienen por objetivo resolver
un problema especifico. La mayoría de las veces este
conjunto de instrucciones es parte de un algoritmo de
mayor tamaño, donde las funciones tienen como objetivo
la división de un problema en problemas más pequeños y

87
sencillos, los que en su conjunto resuelven el problema

mayor.
Supongamos que deseas conocer el vuelto de la compra

de varios productos del mismo precio, el precio de ellos
no incluye el IVA por lo que hay que sumarlo, una vez se
obtiene el total a pagar hay que determinar cuanto es el
vuelto según el monto cancelado.
Los datos de entrada para este problema son:
 Cantidad de productos.
 Precio.
 Monto cancelado.
 El valor del IVA
La salida:
 Vuelto.
El proceso:
Multiplicar el precio por la cantidad de productos, sumar

el 19% para obtener el valor a pagar y luego al monto
cancelado restar el valor a pagar.
Este proceso puede ser dividido en partes más pequeñas

y mucho más fáciles, identifiquemos algunos sub
procesos.
1) Determinar el valor de los productos, este proceso es

sencillísimo, los datos de entrada son sólo el precio y la
cantidad, el proceso es una multiplicación y la salida el
producto de ambos (sub total).

88
2) Calcular el IVA, la entradas es el sub total el cual

calculamos en el paso anterior, el proceso agregar el
19% y la salida será el total.
3) Calcular el vuelto, los datos de entrada son el total y el
monto cancelado, el proceso es restar al monto el total,
la salida es el vuelto o el monto adeudado.
Estos tres procesos son pequeños programas con una

dificultad mucho menor que el total, por ende también
son más sencillos de programar, lo importante es
reconocer las entradas y las salidas de cada uno de ellos,
así como también tener en consideración que alguna
combinación de ellos dará el resultado final. Además de
todo lo anterior el control y la corrección se hace más
fácil, por ejemplo, supongamos que has entregado un
software encargado de realizar distintos cálculos
algebraicos y el resultado de ello son alrededor de 200
líneas de código, llena de bifurcaciones, sentencias switch
y varios bucles, es probable que luego de un corto tiempo
no recuerdes qué lógica usaste o para qué sirve cada una
de las variables que utilizaste. Ahora tratemos de corregir
el cálculo de la tangente de un circulo, lo que sin duda
alguna podrá generar más de algún dolor de cabeza
debido a que el código está en algún lugar dentro de las
200 líneas y lo que es peor no sabemos si el cambio del
valor de alguna variable pueda afectar otros cálculos que
la utilizan dentro del mismo ámbito, sin embargo si
nuestro código esta dividido en pequeños sub programas,
donde cada una de las partes reciben nombres
apropiados y descriptivos de lo que hacen como por

89
ejemplo “AreaCirculo” “perimetroCuadrado” donde cada

uno de estos programas pequeños tienen sus propias
variables y un proceso que no depende del resto, por
ende sólo tendrás que hacer la mantención de ese
pequeño sub programa, donde el código es más limpio y
fácil de entender, adicionalmente el cambio sólo afecta a
las partes que lo utilicen y no a todo el programa.
Estructura de una función

Existen dos tipos de subprogramas, las funciones y los
procedimientos, los cuales pasaron a llamarse métodos
con la programación orientada a objetos, la cual veremos
más adelante, mientras tanto procederemos a estudiar en
qué consiste cada una de ellas.
Procedimientos
Representa una porción de código agrupada con un

nombre que describa lo que hace. Las sentencias
contenidas en dicho procedimiento pueden ser ejecutadas
cuantas veces se quiera, adicionalmente un
procedimiento puede de forma opcional recibir
parámetros de entrada, con el fin de que en base a los
valores de dichos parámetros el procedimiento ejecute
alguna acción.
Una característica importante del procedimiento es que el

proceso que se ejecuta dentro nunca retorna un
resultado, por ejemplo, si necesitas hacer un
comportamiento al que le entregas dos valores para que

90
los sume, entonces el procedimiento deberá hacer el

proceso de sumar ambos, pero no tendrá la facultad para
devolverte el resultado, a cambio le puedes pedir que lo
muestre por pantalla, que lo imprima u algún otro tipo de
salida, pero nunca esperes respuesta. Otro buen ejemplo
será un procedimiento que se llame correr, el que
supongamos incrementa la variable cansancio en 1 y
estado físico en 2, como puedes ver el procedimiento
descrito se ha ocupado de cambiar valores a variables,
pero no ha retornado un resultado.
Los procedimientos pueden recibir de forma opcional

parámetros, los parámetros como lo mencionamos antes
tienen la función de determinar como se ejecutará dicho
procedimiento. Aclaremos esto un poco más,
supongamos que un procedimiento llamado saludar al
ejecutarlo imprime por pantalla la cadena “hola amigo”,
este procedimiento será utilizado por el programa
principal cada vez que necesite imprimir dicho mensaje,
evitando así codificarlo varias veces, sin embargo el
mensaje jamás variará por lo que aseguramos que el
procedimiento saludar siempre imprimirá el mismo
mensaje sin excepción. Si deseamos que éste tenga un
comportamiento variable y que imprima “hola Anakin”,
“hola Obi Wan” o algún otro nombre, entonces debemos
determinar qué es lo que variará y qué no, de esta forma
podemos determinar de forma muy fácil que el parámetro
de entrada corresponde a un nombre (la parte variable) y
que “hola” es parte del procedimiento. El proceso que se
llevará a cabo es la unión (concatenación) de “hola” con

91
el valor de la variable que represente el nombre, de esta

forma si deseas mostrar “hola Sebastián, tienes 29 años”,
bastará con agregar un segundo parámetro de entrada
que contenga la edad. De esta forma un procedimiento
tendrá todos los parámetros que desees, debes
considerar que si decides entregar nombre y edad,
entonces ya nunca más podrás entregar al procedimiento
sólo la edad ya que los parámetros de entrada que
definas en un procedimiento se convierten en una
obligación para su ejecución, sin embargo puedes según
los valores tomar acciones, por ejemplo si la edad es cero
omitir la parte que dice “tengo xx años”. (Más adelante
en el capitulo de POO veremos como una técnica llamada
sobrecarga nos facilita esto aún más).
Dado entonces que los procedimientos no retornan un

valor, todos ellos utilizan la palabra reservada void para
indicarlo, donde void significa la no existencia de un tipo
de datos.
A la derecha de la palabra reservada void indicaremos el

nombre del procedimiento, el cual debe ser un nombre
que describa lo que hace y cuyo proceso intelectual para
inventarlo es nuestro, por ejemplo “saludar”
La tercera parte corresponde a los parámetros de entrada

de nuestro programa, partiremos analizando un ejemplo
que no recibe parámetros y que imprime el mensaje de
“hola” como lo vimos antes.

92
void saludar()
{
//tu código aquí
}
Como muestra el código anterior el procedimiento saludar

se acompaña de paréntesis vacíos, lo que significa que
no recibe parámetro alguno. Las llaves representan el
inicio y término del cuerpo de nuestro procedimiento, en
él debemos agregar toda la lógica referente a nuestro
proceso saludar, el cual lucirá así:
void saludar()
{
System.out.println(“Hola”);
}
Para recibir parámetros debemos especificar para cada

uno de ellos su tipo y nombre de la variable que contiene
el valor de entrada. Agreguemos al código realizado la
posibilidad de mostrar un nombre distinto cada vez.
void saludar(String nombre)

{
System.out.println(“Hola ” + nombre);
}
Como puedes ver este método imprimirá el mensaje de

“hola “ y lo concatenará con el valor de la variable
nombre. La obtención del valor de dicha variable no es
una responsabilidad del procedimiento saludar, recuerda
que este es un sub programita cuya responsabilidad es

93
sólo generar el mensaje, por ende este comportamiento

deberá ser utilizado por el programa principal, quien
recurrirá a el cada vez que necesite generar un saludo,
sin embargo el procedimiento como requisito para
generar su objetivo requerirá que se le entregue algún
nombre. Supongamos ahora que queremos mostrar
también la edad, en ese caso debemos agregar un nuevo
parámetro con su respectivo tipo, veamos como utilizar
un segundo parámetro de entrada para nuestro
procedimiento.
void saludar(String nombre, int edad)

{
System.out.println(“Hola ” + nombre + “, tengo “ + edad
+ “ años”);
}
A partir del segundo parámetro en adelante debemos

utilizar una coma para separarlos, de esta forma podrás
agregar cuantos parámetros consideres necesario como
requisito para ejecutar tu procedimiento.
Por otra parte el cuerpo de nuestro procedimiento llevará

todas las líneas de código que desees, sin embargo debes
tener muy presente de que los inicios y cierres de bloque
definen el ámbito (la frontera) de nuestra función, esto
significa que todas las variables que allí se declaren
estarán disponibles sólo dentro de la función esta regla
también es valida para los parámetros que recibe.
veamos un ejemplo:

94
void saludar(String nombre, int edad)

{
int codigo = 66;
System.out.println(“Hola ” + nombre + “, tengo “ + edad
+ “ años y mi código de trabajador es:” + codigo);
}
void despedir()
{
System.out.println(“chao, recuerden que mi nombre es ”
+ nombre + “ y tengo “ + edad + “ años y mi código de
trabajador es:” + codigo);
El procedimiento saludar tiene 3 variables declaradas en

su ámbito, dos de ellas son nombre y edad, cuyas valores
vienen asignados desde otro lugar del código y son
recibidos como una entrada. La variable código en cambio
es declarada como una nueva variable e inicializada
dentro del método, pero las tres tienen el mismo ámbito
pudiendo usarse cualquiera de ellas dentro de los límites
del procedimiento. Si miramos el procedimiento despedir
en cambio aseguraremos que existen 3 errores, los
cuales corresponden a la utilización de las variables
nombres, edad y código, ya que ninguna de las tres
existe en este ámbito. Si desean usarse hay que
recibirlas como parámetro o declararlas dentro del
método, ambas alternativas son correctas, pero la
diferencia la determinará si deseas que los valores sean
asignados dentro del método (el caso de código en el

95
método saludar) o como parámetros cuyo uso representa

un valor que viene desde fuera del procedimiento.
Dado que como lo mencionamos antes una variable

declarada dentro de un procedimiento define el ámbito en
el que la variable vive, veamos el siguiente código:
void saludar()
{
int var1 = 66;
}
void despedir()
{
int var1 = 66;
}
En el código anterior la variable var1 ha sido declarada

en ambos procedimientos, esto no provocará un error ya
que ambas variables viven en un ámbito diferente y el
cambio en el valor de alguna de ellas no afectará el
valor de la otra, ya que si bien comparten un mismo
identificador son variables totalmente distintas.
Función
Una función es muy similar a un procedimiento, con la

salvedad de que la función debe retornar algún valor, o
dicho de otra forma el proceso dentro de la función debe
generar algún resultado en algún tipo de datos conocido

96
para retornarlo a quien llame al procedimiento. Un

ejemplo será el comportamiento sumar, el cual recibirá
dos parámetros y cuyo resultado de la suma no será una
impresión por pantalla, el resultado generado será
devuelto a quien llame a la función como un valor
representado por alguno de los tipos de datos que tenga
el lenguaje, la función utiliza la palabra reservada return
para realizar el retorno del resultado del proceso, por ello
return siempre debe estar presente y su ejecución
significa también el final de la función, ya que una vez se
retorna el resultado significa que la función ha finalizado.
int suma(int a, int b)

{
int c = a + b;
return c;
}
El código anterior es un ejemplo de la función suma, en

este caso y al igual que en el procedimiento, la función
recibe dos parámetros de tipo entero, la diferencia está
dada en que void ha sido remplazada por int, el cual
define el tipo de dato que la función va a retornar, en
este caso se ha utilizado int dado que la suma de a y b
representarán un entero. Así una función podrá retornar
cualquier tipo de datos conocido por el lenguaje. Luego
de la operatoria encontraras la sentencia return c, la cual
contiene el resultado de la operatoria a+b y cuyo
resultado concuerda con el tipo que explicitamos que la
función retornaría.

97
Llamada a una función

En la programación estructurada las funciones y
procedimientos acompañan el método principal, llevando
parte de la lógica a ellas, las cuales tienen como
propósito resolver problemas más pequeños, hacer más
fácil la programación y reutilizar el trabajo ya hecho. Una
función que nos indique si un archivo existe en nuestro
disco duro es un buen ejemplo, la próxima vez que se
necesite verificar la existencia de un archivo bastará con
llamar a dicha función entregando la ruta del archivo a
buscar, estas tareas específicas no tienen sentido por sí
solas, casi siempre son parte de un programa que tiene
algún propósito mayor y este programa es el encargado
de llamar a una o mas funciones para lograr el objetivo.
Durante este capitulo veremos cómo utilizar las funciones

desde el punto de vista estructurado y más adelante
veremos como las funciones son utilizadas en la
programación orientada a objetos.
La forma en la que las utilizaremos dependerá de dos

factores, lo primero a considerar es si lo que estamos
llamando es un procedimiento o función, ya que la
primera diferencia entre ellos es su retorno. Recuerda
que un procedimiento no retornará nada, sin embargo si
llamamos una función debemos esperar algún resultado,
el otro factor corresponde a los parámetros que reciben,
para ambos casos hay que considerar cuantas variables
hay que enviarle al procedimiento o función y de qué
tipos son.

98
Comenzaremos con el caso más sencillo e iremos

transformando un programa simple en un programa
dividido en funciones, supongamos que tenemos el
siguiente código:
public class JavaApplication2 {
public void miEjemplo() {
int fechaNacimiento=1982;
String nombre = “sebastian”;
int fechaActual = 2012;
int edad = 0;
edad = fechaActual - fechaNacimiento;
String correo = nombre + edad + “@” +

“empresa.cl”
System.out.println("Hola mi nombre es " + nombre

+ ", tengo " + edad + "años y mi correo es " + correo);
Este pequeño programa presenta el nombre y la edad de

una persona, la cual se ha calculado sólo considerando el
año de nacimiento, por lo que en este simplificado
ejemplo es posible que la falta de la inclusión de los
meses produzca alguna diferencia, el cálculo que se
almacena en una variable edad que es después
desplegada como parte del mensaje, además el correo de

99
la persona también se muestra, pero previo a ello se

genera basándose en el nombre y la edad de la persona y
se le agrega @empresa.cl. Si hacemos un pequeño
análisis aquí hay 3 pequeñas funcionalidades que pueden
ser fácilmente llevadas funciones y procedimientos.
1) Calculo de la edad
2) Generación del correo.
3) Presentación de la persona mediante una impresión.
El paso siguiente será determinar cómo debemos

modularizar estas funcionalidades, especificando cuales
serán procedimientos, cuales deben ser funciones y que
valores deben recibir. Si hacemos un pequeño análisis
nos daremos cuenta que algunas variables como por
ejemplo el nombre, deben ser conocidos por dos de los
tres procesos. Primero la debemos utilizar para la
generación del correo y luego en el paso número tres
para la impresión, esto nos indica rápidamente que el
nombre no es una variable exclusiva de ninguno de los
dos, ya que si se declara dentro de alguno de los dos
métodos la variable y su valor estaría sólo disponible
dentro de él, por lo tanto la variable nombre debe
declararse en el método miEjemplo ya que este será el
encargado de llamar a las demás funciones pudiendo así
pasarlas de una a otra sin perder la variable. Esto se
deberá a que las funciones que vaya llamando miejemplo
crearán sus variables que tengan declaradas, pero al
finalizar su ejecución todas ellas serán destruidas, sin
embargo, miEjemplo estará activo durante todo el

100
proceso, llamando y ejecutando las funciones que en el

programamos.
Comencemos entonces a desmenuzar este problema en

pequeños “problemitas”, analicemos el proceso del
cálculo de la edad. Para realizarlo lo que necesitamos es
la fecha de nacimiento y la fecha actual, el proceso es la
resta de ambas y el resultado la edad, por lo tanto
cuando miejemplo llame la función que se encarga de
calcular la edad debe especificar ambos parámetros y
luego esperar la respuesta de la función, la cual
corresponde a la edad calculada. Este valor de retorno
nos indica que la función no puede ser un procedimiento,
dado que debe retornar el valor para que luego dicho
valor sea mostrado en el mensaje, entonces nuestro
pequeño programa queda así:
int calcularEdad(int fechaNacimiento, int FechaActual)

{
int edad = fechaActual- fechaNacimiento;
return edad;
}
La función recibe ambos parámetros como un entero y

retorna la resta de ellos, valor que también es de tipo int.
La variable edad que está declarada al interior sólo vive
dentro de calcularEdad y no es compartida con nadie,
sin embargo la última línea de código se encarga de
retornar el valor de tipo entero que aseguramos
retornaríamos. Debes tener cuidado con no confundirte,
la función no retorna una variable, lo que hace es

101
devolver el valor de ella, según sea el resultado debes

imaginar que lo que allí dice es algo así como: return 10
o return 39 según el resultado del cálculo.
Veamos ahora la generación del correo, para ello las

entradas son, la edad y el nombre de la persona, el
proceso es una concatenación de ellos y el resultado (el
valor a devolver) el correo, este proceso entonces lucirá
así:
String generarCorreo(String nombre, int edad)

{
String email = nombre + edad + “@” + “empresa.cl”;
return email;
}
En este caso el tipo de retorno será un String y ello se

notifica a la izquierda del nombre de la función, también
recibe dos parámetros los cuales son el nombre y la
edad. Fíjate que la edad se asume viene calculada, ya
que no es responsabilidad del método generarCorreo
realizar este calculo, para ello hemos escrito otra función.
Luego de la concatenación el método retorna el valor de
la variable email hacia miEjemplo.
Finalmente el módulo que realiza la impresión será un

procedimiento, ya que no hay un valor que deseemos
retornar hacia mi Ejemplo, sin embargo para lograr la
impresión necesitaremos el nombre, la edad y el correo.
void imprimirDatos(String nombre, int edad, String

correo)

102
{
System.out.println("Hola mi nombre es " + nombre + ",
tengo " + edad + "años y mi correo es " + correo);
}
En este caso la impresión no es un valor que vayamos a

devolver, por esto el procedimiento no lleva return y en
su firma informa que el tipo de retorno es void, vale decir
que no hay retorno.
Para unir todo el método miejemplo será el encargado

llamar a todas las funciones y dar el orden lógico de
ejecución, luego de recodificar el código el miejemplo
lucirá así:
int fechaNacimiento=1982;
int fechaActual = 2012;
int edad =
calcularEdad(fechaNacimiento,fechaActual);
String correo =generarCorreo(nombre,edad);
imprimirDatos(nombre,edad,correo);

103
Como puedes ver leer el programa es mucho más sencillo

ahora, ya que palabras como calcularEdad dejan de
forma más explicita lo que hace esa línea, fíjate que para
ejecutar ese método es necesario pasar dos parámetros,
estos deben ir separados por coma y en el mismo orden
en el que la función esta declarada, al igual que antes no
es la variable la que se entrega sino el valor de ellas,
también es valido entonces solicitar a la función
calcularEdad que lo haga llamándola de la siguiente
forma:
int edad = calcularEdad(1982,2012);

En este caso a la llamada a “calcularEdad” se le entregan

los valores explícitamente, eso también esta correcto ya
que ambos valores son recibidos en las variables
declaradas dentro de la función, se resta y se retorna el
resultado, el cual guardamos en una variable declarada
dentro de miejemplo que se llama edad.
 Una nota importante, si bien la variable de la que se

retorna el valor en calcularEdad se llama igual que la

104
variable en la que miEjemplo lo recibe no significa que

esto deba ser así, recuerda que las variables están en
ámbitos distintos y por ende son variables totalmente
independientes, por esto los nombres que utilicen no
generaran alguna diferencia, pudiendo ellas llamarse
iguales o tener nombres diferente, recuerda que la
variable edad de miejemplo lo que recibe es un número
(el valor de la variable edad de calcularEdad)
Al igual que en calcular edad en generarCorreo debemos

recibir el valor de retorno, el cual en este caso es una
concatenación que simula el correo del usuario y que
almacenamos en una variable llamada correo.
Finalmente para llamar a imprimirDatos no hay una

asignación (signo igual) dado que este es un
procedimiento que ejecuta una o más líneas de código
pero no retorna un valor, sin embargo si recibe tres
parámetros los cuales al igual que antes deben ser
entregados en el mismo orden y con sus tipos de datos
correspondientes.
El código completo quedará de la siguiente forma, donde

los procedimientos y funciones son agregados al código,
no importa su orden, sólo importa el orden en el que
miejemplo los utiliza, siendo entonces miejemplo el
punto de inicio de nuestro algoritmo y de allí se
ejecuta todo lo demás.

105


correo)
{
}

{
return email;
}

{
return edad;
}

106
Con las llamadas a las funciones y/o procedimientos

puedes utilizar todas las combinaciones que gustes,
observa este ejemplo, el cual hace lo mismo pero de otra
forma, he aquí el código y luego la explicación.

imprimirDatos(nombre,edad,
generarCorreo(nombre,edad));

correo)
{
}

{
return email;
}

{

107
return edad;
}
En este caso la línea que asignaba el correo ha sido

eliminada, sin embargo para obtener el correo y luego
poder imprimirlo remplazamos la variable correo que ya
no está por la llamada al método generarCorreo, esto es
posible ya que el método lo que solicita es un string con
el correo y dado que el orden de ejecución es desde
adentro hacia afuera, primero se ejecutará la función
generarCorreo la cual retornará un String y cuyo valor es
entregado a imprimir. De esta misma forma también
podrás llamar a funciones desde otras funciones y/o
procedimientos como muestra el siguiente cambio
realizado a imprimir.

correo)
{
tengo " + edad + "años y mi correo es " +
generarCorreo(nombre,edad);
}
En este caso para obtener el correo le pedimos

directamente desde dentro de imprimirDatos.

108
Arreglos
Un arreglo es un grupo de variables de un mismo tipo, las
cuales son referenciadas con un mismo nombre. Los
arreglos existen en más de una dimensión, siendo los
arreglos de una dimensión (o sólo arreglos) los más
comunes y los de dos dimensiones (matrices),
afortunadamente para los conocedores de lenguajes
como C o C++ los arreglos y matrices serán algo familiar,
sin embargo no son exactamente iguales, ya que existen
algunas diferencias en su sintaxis.
Unidimensionales
Los arreglos de una dimensión, permiten almacenar una
cantidad N de variables de un tipo, la declaración general
de un arreglo es la siguiente:
Tipo identificador [ ];
Por ejemplo:
Para este caso la declaración ha creado una variable

llamada mes que permitirá referenciar a nuestro arreglo,
sin embargo aún el arreglo no se ha creado y mucho
menos definido su tamaño, esto significa que en mes aún

109
no es posible almacenar valores. Para obtener un arreglo

de tamaño n, se debe ejecutar la siguiente sintaxis.
• Declaración = new tipo[tamaño]
De esta forma se reservará el espacio de memoria que

permitirá almacenar una n cantidad de elementos, la
palabra clave new crea dicho arreglo con los valores por
defecto del tipo especificado, por ejemplo, la siguiente
declaración declara y construye un arreglo de tamaño 12,
donde cada entero dentro del arreglo es inicializado en
0:
mes es un arreglo capaz de almacenar 12 números de

tipo entero, los elementos están almacenados de forma
adyacente y se pueden referenciar utilizando un número
entre 0 y 11 (12 en total). Por ejemplo, el siguiente
código almacena el valor de 10 en la posición 1 del
arreglo, de forma adicional, si cada posición tuviese
directa equivalencia con el nombre de un mes, la posición
1 seria febrero, ya que, 0 es la primera posición y
equivaldría a enero, luego 1 es igual a Febrero.
A pesar de no ser muy común los arreglos también

pueden ser inicializados, por ejemplo el siguiente código
crea el arreglo mes con un valor para sus 12 enteros:

110
Note, que de esta forma el tamaño del largo está

indicado por la cantidad de elementos con el que se
inicializa.
El ciclo for estudiado en capítulos anteriores es el

utilizado de forma más común en la operatoria con
arreglos, el siguiente código muestra la forma de
imprimir todos los valores del arreglo mes:
La salida del dicho código será:

111
Arreglos de dos dimensiones.

Los arreglos multidimensionales son en realidad arreglos
que contienen otros arreglos. Es muy común asociar un
arreglo multidimensional con una matriz, sin embargo las
matrices son sólo una posibilidad dentro de la enorme
cantidad de combinaciones que permite trabajar con
arreglos de arreglos. El siguiente código permite declarar
un arreglo en dos dimensiones.
Para este caso nuestro elemento es de tipo rectangular,

dado por 4 filas y 5 columnas, como muestra la siguiente
tabla.
[0][0] [0][1] [0][2] [0][3] [0][4]

112
[1][0] [1][1] [1][2] [1][3] [1][4]

[2][0] [2][1] [2][2] [2][3] [2][4]
[3][0] [3][1] [3][2] [3][3] [3][4]
Por lo tanto, toda operatoria con arreglos de dos

dimensiones, debe especificar las dos dimensiones para
poder referenciar un elemento dentro de la estructura,
por ejemplo, el siguiente código muestra cómo se asigna
el valor de 10 al tercer elemento de la segunda fila.
La siguiente tabla muestra los valores que contiene la
matriz.
0 0 0 0 0
0 0 10 0 0
0 0 0 0 0
0 0 0 0 0
Note que la tabla anterior muestra los valores por defecto

que tiene nuestra matriz, sin embargo es importante
comentar que la tabla muestra una vista conceptual de
cómo se almacenan los datos en una matriz, dado que en
la memoria física los datos no son almacenados con esta
estructura. El siguiente algoritmo permite poblar una
matriz de 4 x 5 con los números desde el 1 al 20:

113
Arreglos de arreglos.
Es muy usual que cuando se trabaja con arreglos de dos
dimensiones, muchos asociamos inmediatamente la
estructura con una forma rectangular, si vamos más allá,
descubriremos que en Java también pueden declararse
arreglos multidimensionales de tres dimensiones de la
siguiente forma:
sin embargo, es sólo el comienzo, ya que, en Java

puedes agregar todas las dimensiones que desees ¿Cómo
es eso posible? la respuesta no es tan compleja como se
piensa, sucede que una matriz, en realidad no es un
rectángulo, sino que, arreglos de arreglos, por ejemplo,

114
la matriz vista anteriormente de 4 filas y 5 columnas, en

la memoria se encuentra almacenada de la siguiente
forma:
Como se puede apreciar, existe en realidad un arreglo de

4 elementos, pero cada uno de ellos es además un
arreglo de 5 posiciones, por ello la anotación de una
matriz es [][] (arreglos de arreglos), por ende, cuando se
escribe una referencia a algún elemento como:
Se está en realidad diciendo, que en el arreglo que ocupa

la posición 1 (es decir el segundo elemento, dado que
comienza de cero) almacenamos en su posición 2 (la
tercera) el valor de 10. De esta forma el siguiente
ejemplo muestra como luce un arreglo de tres
dimensiones:

115

Inacap - Introducción A Lenguajes Formales de Programación PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Inacap - Introducción A Lenguajes Formales de Programación PDF

Загружено:

Авторское право:

Доступные форматы

65

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

Los Atributos que representarán un objeto, por ejemplo,

Accesadores y mutadores, los cuales son

Los comportamientos que un objeto tendrá, por ejemplo,

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

Una condición esta antecedida de la conjunción si (sin

Si mi amigo va, yo voy.

Si estoy aburrido jugaré PC.

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

Si me han enseñado algo nuevo lo reforzaré.

Fíjate que en cada una de las frases anteriores hay una

En informática este comportamiento es exactamente

if mi amigo va, yo voy.

if estoy aburrido jugaré PC.

if me han enseñado algo nuevo lo reforzaré.

Bien, ya nos vamos acercando a nuestra meta y de lo

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

if (plata >= 10000)

Donde plata es una variable que contiene algún valor el

Supongamos ahora que si la condición se cumple

if(plata >= 10000)

Como puedes ver justo debajo de la condición el

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

bloques delimitan el alcance de la condición, es decir

if(plata >= 10000)

en este caso tenemos dos incrementos, el de la variable

Hasta ahora hemos visto como debiese comportarse el

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

caso “sino es verdadera”. Para ello utilizaremos la

if(plata >= 10000)

Como puedes ver en el caso anterior si la condición no se

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

if(plata >= 10000)

Al igual que el caso anterior la variable tiempo esta luego

La mayoría de las veces, el cumplimiento o no de una

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

if(plata >= 10000)

Así como muestra el ejemplo puedes agregar todas las

if(plata >= 10000)

Aquí lo que tratamos de hacer es establecer sólo el caso

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

escrito de forma mucho más clara cambiando la condición

if(plata < 10000)

Veamos ahora un caso un poco más complejo, no

if(plata >= 10000 && temperatura >17)

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

En este caso para que se incremente diversión y

Veamos otro ejemplo, supongamos ahora que no deseas

if(plataAmigo1 >= 10000 || plataAmigo2>= 10000)

Utilizamos entonces || para representar la condición O,

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

asumamos que si llevamos sobre los $15.000 podemos

if(plata >= 10000 && temperatura >17)

if(plata >= 15000)

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

En el código anterior si la condición que nos va a permitir

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

que evaluar si es B o C, la forma de realizar esto es

en el ejemplo anterior le pedimos a switch que evalué el

UNIVERSIDAD TECNOLÓGICA DE CHILE INACAP - ÁREA INFORMÁTICA Y TELECOMUNICACIONES

ejecutar, supongamos que si sacas una C tu animo decae

Sentencias de ciclo iterativo