Bibilia de Don Juan Corvalan

Escuela de informtica y telecomunicaciones
Ingeniera en Informtica
Apuntes de programacin
Enero-2010
2
Contenido
Contenido............................................................................................................................ 2
Introduccin......................................................................................................................... 4
Qu es programar?........................................................................................................... 4
Construccin de programas en Java...................................................................................5
La programacin orientada al obeto...................................................................................!
"alabras reservadas............................................................................................................ #
$ipos de datos..................................................................................................................... #
%peradores &atem'ticos.................................................................................................. ()
%peradores de Incremento * +ecremento.........................................................................()
%peradores ,elacionales.................................................................................................. (4
%peradores Condicionales................................................................................................ (4
&todos............................................................................................................................ (5
Constructores.................................................................................................................... (-
&odi.icadores de acceso................................................................................................... 2(
&todos accesadores * mutadores...................................................................................22
Ingreso de in.ormacin desde teclado...............................................................................24
Casteo o moldeo de valores.............................................................................................. )/
+ocumentacin de los programas.....................................................................................)(
La clase &at0.................................................................................................................... 4(
1entencias de control........................................................................................................ 44
1entencias condicionales.................................................................................................. 45
1entencia s2itc0............................................................................................................... 55
1entencias de control iterativas......................................................................................... !2
)
1entencia de control iterativa 20ile 3mientras4..................................................................!2
1entencia de control iterativa do520ile..............................................................................62
7alidacin.......................................................................................................................... 6)
1entencia iterativa 8or....................................................................................................... -(
9rreglos............................................................................................................................. -)
Clases colaboradoras........................................................................................................ #)
Clase 1tring....................................................................................................................... #4
Creacin de clases colaboradoras....................................................................................#5
4
Introduccin
Estos apuntes de programacin pretenden ser una gua para los alumnos de primer semestre
de la carrera de ingeniera informtica, una ayuda al entendimiento de la programacin y al
desarrollo del pensamiento y conocimiento informtico.
La programacin es igual a cualuier otra disciplina como matemticas, umica, etc.
donde es profundamente importante el estudio y la dedicacin ue cada uno comprometa.
!or e"emplo, el tenista #ernando $on%le% o el gimnasta &omas $on%le%, son triunfadores
en sus respecti'as disciplinas, pero ellos in'ierten muc(as (oras diarias en un fuerte
entrenamiento para lograr estos triunfos. )i nosotros ueremos ser un #ernando $on%le%
de la programacin de*emos imitar su esfuer%o y practicar diariamente 'arias (oras (asta
ue mane"emos los remac(es y los saues de la computacin.
Qu es programar?
!rogramar es la ela*oracin de +algoritmos, para la resolucin de pro*lemas, pero escritos
en alg-n lengua"e computacional. .on esto tenemos dos t/rminos nue'os ue de*emos
conocer0
Algoritmo y lengua"e computacional.
1n algoritmo es una secuencia de pasos lgicos consecuti'os ue apuntan a la resolucin
de un pro*lema y un lengua"e computacional es un idioma ue permite la comunicacin
entre los programadores 2nosotros3 y los computadores. !or lo tanto, nuestros esfuer%os
apuntaran al desarrollo de algoritmos y al aprendi%a"e de este nue'o idioma ue de*emos
mane"ar.
Los lengua"es computacionales son muc(os 2pascal, co*ol, ., 4a'a, .5, etc.3 y (an ido
e'olucionando con el tiempo, (oy los lengua"es ms utili%ados son auellos +orientados al
o*"eto, y el lengua"e ue nosotros aprenderemos esta dentro de estos y corresponde a
+4a'a,.
6!or u/ 4a'a7
El principal moti'o para aprender este lengua"e es por (oy en da es uno de los ms
utili%ados, pro*a*lemente gran parte del mercado de desarrollo del aplicaciones de todo
tipo se (ace en 4a'a o punto 8et 2.8et3 donde este ultimo corresponde a una iniciati'a de la
empresa 9icrosoft, la cual desarroll un lengua"e propio *asado en las 'enta"as de 4a'a.
Adems 4a'a es un lengua"e li*re, esto significa ue no de*o pagar por utili%arlo o por
'ender aplicaciones construidas con /l, si deseo tener /ste lengua"e *asta con ingresar a la
pgina de la )18 y *a"arlo 2(ttp0::;;;.sun.com:3.
6!or u/ 4a'a es tan utili%ado7
5
<ueno, siendo realistas no slo 4a'a se utili%a ampliamente sino tam*i/n punto net y en
general todos los lengua"es orientados al o*"eto, donde la gran mayora de los lengua"es
tienen como ra% de origen a 4a'a.
La importancia de estos lengua"es est en ue su programacin se (ace orientada al o*"eto y
esta forma de programar presenta un sinn-mero de 'enta"as como0
Encapsulacin de la informacin
=eutili%acin del cdigo
!orta*ilidad
Escala*ilidad
Construccin de programas en Java
!ara construir un programa en 4a'a de*o tipiar las instrucciones en alg-n editor de te>to
como el *loc? de notas o *ien en alg-n I@E 2integrated de'elopment en'ironment3 como
4.reator, <lue4, 8et<eans o Eclipse entre otros. )i uso el *loc? de notas de*o, una 'e%
tipiado el programa cam*iar la e>tensin del arc(i'o por ."a'a.
.omo segundo paso el programa se de*e +compilar,, proceso en ue el e"ecuta*le +4a'ac,
es in'ocado y reali%a una re'isin de la escritura, si esta sigue las reglas *sicas, si es as, el
sistema informa ue el programa fue compilado y aparece un nue'o arc(i'o llamado igual
al inicial pero con e>tensin .class, este arc(i'o est construido en *ycode, el cual es un
lengua"e intermedio entre cdigo de muina y cdigo fuente sin ser ninguno de los dos,
a(ora estamos listos para e"ecutar el programa para ello de*emos in'ocar al e"ecuta*le
+"a'a,, el cual lo ue (ace es tomar el compilado 2.class3 y mediante la 4A9 2muina
'irtual de 4a'a3 transformarlo a lengua"e de muina para el sistema operati'o donde se
est parado y permitir la e"ecucin del programa. La figura representa los pasos y cam*ios
ue tiene un programa desde su digitacin (asta su e"ecucin.
!
.onstruyamos nuestro primer programa0
class Bola4a'a
C
pu*lic static 'oid main2)tring DE arg3
C
)ystem.out.println2FBola 4a'aGGF3H
I

I
.omo (emos 'isto en la construccin de nuestro primer programa comen%amos con la
pala*ra class, la cual es una pala*ra reser'ada del lengua"e e indica ue el *loue ue se
construye es una clase y esta es la unidad *sica donde se construyen generalmente los
programas.
@entro de esta clase podemos 'er otro *loue ue lle'a como nom*re +main,, las clases
estn compuestas por su*-*loues llamados m/todos, donde el m/todo main indica ue esta
clase es e"ecuta*le, si este m/todo no aparece, la clase solo es compila*le.
#inalmente, dentro del *loue main aparece una sentencia ue dice
+)ystem.out.println2+Bola 4a'aGG,3H la cual indica ue el sistema de*e imprimir por pantalla
lo ue se coloca entre comillas dentro del par/ntesis.
La programacin orientada al objeto
Ja sa*emos ue siempre tra*a"aremos con clases y en este curso normalmente tra*a"aremos
con una clase llamada test o aplicacin, ue corresponde a una clase e"ecuta*le 2contiene al
m/todo main3 y otras sin main 2slo compila*les3 ue llamaremos clases plano.
6Bacia dnde apunta todo esto7, esto se enfoca a descri*ir y estudiar nuestro mundo,
nuestro entorno a tra'/s de o*"etos. La pregunta ms *sica ue trataremos de ir
6
contestando durante el semestre es 6Ku/ es un o*"eto7, todos los das 'emos o*"etos pero,
6cmo podemos descri*ir un o*"eto7, *ueno un o*"eto es una +cosa,, pero es una cosa ue
podemos descri*ir en funcin de lo ue tiene y (ace, por e"emplo un lpi% es una cosa y
6cules son las caractersticas ue tiene este lpi%7, tiene largo, tiene dimetro, tiene color,
y 6u/ (ace este lpi%7 escri*e, ralla, di*u"a. Aeamos otro e"emplo0
L*"eto0 una piscina.
!ropiedades0 largo, ancho, profundidad, color.
.omportamiento0 contiene agua.
!odemos 'er ue los o*"etos tienen propiedades y estas se definen como auellas
caractersticas del o*"eto ue son propias de /l, no son calcula*les a partir de otras, por
e"emplo el largo, el anc(o, el alto, el color, la marca, el nom*re, etc. 8o son caractersticas
el rea, el permetro, el 'olumen, un nic?, etc. Adems, los o*"etos tienen comportamiento,
y /ste esta relacionado siempre a lo ue el o*"eto (ace o para el fin ue fue construido y
generalmente es o*teni*le de algunas operaciones *sicas so*re las propiedades. !or
e"emplo podran ser propiedades el rea, el permetro, el 'olumen, un nic?, etc.
Tarea 1. @eclare M o*"etos indicando sus propiedades y comportamientos
En la programacin orientada al o*"eto estas propiedades de los o*"etos se denominan
+atri*utos, y el comportamiento del un o*"eto se descri*e a tra'/s de los +m/todos,. !or lo
tanto el pro*lema principal de la programacin orientada al o*"eto estar en poder descri*ir
en forma adecuada el o*"eto en estudio a tra'/s de sus atri*utos y m/todos. Esta
descripcin se reali%a al interior de la estructura principal de la programacin la cual se
conoce como +clase,. As, la forma ue tendr un programa es algo similar a0
!ensando en el o*"eto piscina0
clase !iscina
C Zona donde se indica el inicio del programa
largo
anc(o Zona donde indicamos los atributos o caractersticas
profundidad del objeto
color
cantidadNdeNagua Zona donde indicamos el comportamiento del objeto
mtodos, una piscina est hecha para contener agua, y lo que
nos interesa es cuanta contendr.
I Zona donde se indica el fin del programa.
-
Lo ue (emos construido es una clase ue descri*e como es y cmo se comporta una
piscina, en otras pala*ras cada 'e% ue le demos 'alores a los atri*utos de la clase piscina
o*tendremos un o*"eto del tipo piscina ue tendr una cantidad de agua conocida. Esto
significa ue tenemos el plano para construir muc(as piscinas de diferentes o iguales
tamaOos y esto es lo ue se persigue al programar orientado al o*"eto.
!ara empe%ar a construir nuestros programas en 4a'a de*emos conocer algunas reglas de
escritura de estos. Estas reglas ue 'eremos no son o*ligatorias ms *ien son con'enciones
para ue todos los programadores entendamos lo mismo, as un programador en la .(ina
puede entender el cdigo ue escri*i un programador en .(ile.
Primera regla: El nom*re de una clase siempre empie%a con may-scula y si est
compuesto por 'arias pala*ras cada una de ellas empe%ar con may-sculas y todas de*en ir
pegadas. &am*i/n se acostum*ra ue el nom*re de la clase indiue el tipo de o*"etos ue
permite descri*ir. Es importante indicar ue el nom*re de la clase es el mismo ue tiene el
arc(i'o ue la contiene. E"emplo0
Lapi%
Lapi%!asta
Lapi%!astaA%ul
Segunda regla: El nom*re de los atri*utos del o*"eto siempre se escri*ir con min-sculas y
si estn formados por 'arias pala*ras se pueden separar por una guion *a"o o *ien de"ar
todas las pala*ras "untas. )e acostum*ra ue el nom*re del atri*uto indiue o contenga
claramente lo ue representa. E"emplo0
largo
largoNdelNlapi%
largoNdelNlapi%NpastaNa%ul
Tercera regla0 El nom*re de los m/todos siempre se escri*ir su primera letra con
min-scula y si est formado por ms de una pala*ra, la primera letra de cada pala*ra
empe%ara con may-scula. )e acostum*ra ue en nom*re del m/todo indiue claramente el
comportamiento ue representa o *ien lo ue (ace. Adems el nom*re de los m/todos
siempre termina con par/ntesis redondos 2a*re y cierra par/ntesis, pudiendo o no lle'ar en
su interior informacin adicional3. E"emplo0
di*u"a23
#
di*u"aLineas23
di*u"aLineasA%ules23
Adicionalmente, podemos decir ue un nom*re 2identificador3 de*e comen%ar con letra,
guion *a"o 2N3 o un signo pesos 2P3 y los caracteres siguientes pueden ser ms letras o los
sm*olos ya 'istos o n-meros. Los identificadores "ams podrn comen%ar con un sm*olo
matemtico o tener entre sus caracteres signos de puntuacin, guiones o espacios en *lanco.
&ampoco se puede usar como nom*re pala*ras reser'adas del lengua"e0
Palabras reservadas
Ja conocemos como podemos denominar en nuestros programas a las clases, los atri*utos
y los m/todos. !ero pensemos lo siguiente, en nuestra clase !iscina tenemos como atri*uto
el largo y sa*emos ue la clase ue construimos es un plano ue permite construir todas las
piscinas ue deseemos. Entonces igual ue en los planos de aruitectura de*emos indicar
de u/ tipo de dato estamos (a*lando cuando decimos largo y no solo para este atri*uto
sino ue de*emos especificar en cada atri*uto el tipo de dato ue representa.
A ue nos referimos cuando decimos tipo de dato. Lo ue ueremos e>presar es si el dato
es por e"emplo un n-mero y u/ tipo de n-mero ser por e"emplo real.
Tipos de datos
Los tipos de datos de se agrupan en primiti'os y referenciados
Los tipos de datos primiti'os son0
Enteros: *yte, s(ort, int, long.
(/
byte. Esta 'aria*le puede comprender 'alores num/ricos enteros entre -12Q y R12S. )e caracteri%a
por su ligere%a, ya ue solo ocupa Q *its 2un *yte3, pero su utilidad es reducida.
short. Igual ue *yte, pero ocupando el do*le de memoria 2dos *ytes3 y permitiendo asignar 'alores
muc(o ms grande 2e>actamente desde -T2SUQ (asta T2SUS3. &am*i/n de*e ser un 'alor entero.
int. Lcupa T2 *its 2V *ytes3, pero permite asignar 'alores en un rango especialmente grandeH desde
-21VSVQTUVQ (asta 21VSVQTUVS. .omo en los tipos *yte y s(ort, el 'alor por defecto es 0.
long. Las 'aria*les tipo long ocupan UV *its 2Q *ytes3, ya ue sus 'alores pueden "ugar dentro de un
rango amplsimo 2de -W22TTS20TUQMVSSMQ0Q a W22TTS20TUQMVSSMQ0S3. Al igual ue sus
(ermanos peueOos 2*yte, s(ort e int3, su 'alor por defecto es 0. 1na cosa muy importante es ue a
la (ora de asignar un 'alor a este tipo de 'aria*les, se tiene ue indicar ue se trata de un long
aOadiendo una L 2may-scula3 al final del n-mero.
Reales: float, dou*le.
float. =eal con S dgitos de precisin, al iniciali%ar una 'aria*le real con float de*e lle'ar # o f al
final del n-meroH 2ocupa T2 *its de memoria3, 'alor por defecto 0.0.
double. Igual ue float, pero mayor precisin, 1U dgitos, ocupando UV *its, 'alor por defecto 0.0.
De texto: c(ar.
char. Las 'aria*les pueden contener cualuier carcter, pero uno solo y cuando se asigna
un carcter este de*e colocarse entre comillas simple.
Lgico: *oolean.
boolean. Este tipo de 'aria*le solo puede tomar dos 'alores, o true o false. !or defecto, si no se le
asigna ning-n 'alor, le corresponde el 'alor false.
J los referenciados corresponden a 'aria*les del tipo o*"eto, por e"emplo 'aria*les del tipo )tring,
ArrayList, etc.
Aeamos a(ora como utili%amos estos tipos de datos en las declaraciones de nuestros
atri*utos y cuando usamos un tipo y cuando otro. )e de*e pensar ue la computacin tiene
muc(os aOos de e>istencia y cuando naci las limitaciones de memoria ram y fi"a eran
grandes por eso era muy importante el a(orro de ella, (oy en da, sin *ien es cierto, estas
limitaciones son menores, siempre de*emos recordar ue la memoria no es un recurso
infinito.
!ensemos en un alumno ue tiene edad, se>o, promedio, altura, (a*la ingl/s, n-mero de
gl*ulos ro"os y sueldo.
La edad es entera pero 6de cul tipo7 !ara definir esto de*emos pensar en dos cosas el
rango ue tenemos de edades de alumnos y para ue usaremos este dato. Ja ue si
declaramos la edad como *yte y despu/s ueremos sumar las edades de 'arios alumnos
necesitaremos un tipo de mayor rango para guardar este 'alor, por lo ue se recomienda
((
siempre usar un tipo adecuado donde no se cam*ie cuando se operen los 'alores. Lo ms
recomendado ser utili%ar s(ort.
s(ort edadX21H
El se>o del alumno puede ser mu"er 293 o (om*re 2B3, au no (ay mayores dificultades.
c(ar se>oX Y9ZH
El promedio del alumno est asociado a notas y estas estn en un escala de 1 a S pero como
reales, y no es necesaria una alta precisin.
float promedioXV.MfH
La altura del alumno podemos pensar ue tam*i/n es real y ue necesitamos una mayor
precisin, entonces0
dou*le alturaX1.QMH
Ba*la ingl/s es una 'aria*le ue de*emos responder si o no por lo cual es lgica y tenemos0
*oolean (a*laNinglesXtrueH
El n-mero de gl*ulos ro"os ue posee una persona son muc(os millones y es entero, por lo
tanto0
long numeroNglo*ulosNro"osX2TV12TMUSQW2TLH
#inalmente el sueldo de una persona es entero, nosotros no tenemos monedas de centa'os,
y este a lo sumo podra ser un par de millones por lo cual nos *asta con int.
int sueldoX1200000H
8tese ue para los float y para los long se de*i agregar una letra al final del numero, esta
se usa para indicar al compilador ue el n-mero declarado es del tipo indicado, ya ue para
4a'a cuando yo asigno un entero a una 'aria*les este n-mero es entero pero +int, y cuando
asigno un real este es +dou*le,. &am*i/n es importante indicar ue en cada declaracin de
atri*uto se termino la lnea con punto y coma 2H3, esto se (ace porue en 4a'a todas las
lneas de instruccin de un programa terminan en punto y coma 2H3. Los nom*res de las
clases y los m/todos no son instrucciones.
Tarea 2
!ara los o*"etos declarados en la tarea 1, a(ora defina y asigne los tipos de datos adecuados.
Tarea
(2
@igite las clases ue construy en la tarea 2 y 'ea el comportamiento de las clases al
compilarlas y al incluir o no la letra f o L en los tipos de datos correspondientes.
)i tomamos el e"emplo de la clase alumno y digitamos el primer atri*uto y compilamos
tenemos0
Algo (a pasado porue el sistema no compilo y nos indica ue (ay un pro*lema en la lnea
marcada, 6u/ (a ocurrido7 El mensa"e dice ue espera YHZ de*emos recordar ue toda lnea
de instruccin de un programa termina en H y a(ora de*emos colocar lo faltante y 'ol'er a
compilar. =ecuerde YHZ e>pected significa ue omitimos /l H al final de la instruccin.
A(ora el sistema compilo y el mensa"e as lo indica 2.lass compiled- no synta> errors3.
Ja conocemos como declarar nuestros atri*utos, pero (emos (a*lado poco del
comportamiento del o*"eto 2m/todos3 y generalmente este comportamiento se o*tiene de
operaciones de los atri*utos, por e"emplo pensemos en una clase llamada .asa la cual tiene
como atri*uto largo y anc(o, un comportamiento de esta casa son los metros cuadrados ue
tiene y esto se o*tiene de la multiplicacin de largo por anc(o. Entonces de*emos definir
los distintos operados in'olucrados en la programacin en 4a'a.
()
Operadores atem!ticos
Adicin representado por el sm*olo R, si tenemos num1XM y num2XT entonces
sumXnum1Rnum2 y sum contendr Q.
)ustraccin representado por el sm*olo -, si tenemos num1XM y num2XT entonces
resXnum1Rnum2 y res contendr 2.
@i'isin representado por el sm*olo :, si tenemos num1XM y num2XT entonces
di'Xnum1:num2 y di' contendr 1. )i los 'alores son declarados como enteros el
resultado ser entero y el sistema cortara el resto, no apro>ima.
9ultiplicacin representado por el sm*olo [, si tenemos num1XM y num2XT
entonces mulXnum1[num2 y mul contendr 1M.
9odulo representado por el sm*olo \, si tenemos num1XM y num2XT entonces
modXnum1\num2 y mod contendr 2. El modulo corresponde a el resto 2lo ue
so*ra3 de la di'isin entera y siempre tiene el signo del primer operando.
Operadores de Incremento " #ecremento
!re-incremento, representado por RR'aria*le, ue significa iXiR1, e"emplo si
tenemos0
int iXUH
int "XRRiH
entonces iXS y "XS.
!ost-incremento, representado por 'aria*leRR, ue significa iXiR1, e"emplo si
tenemos0
int iXUH
int "XiRRH
entonces iXS y "XU.
!re-decremento, representado por --'aria*le, ue significa iXi-1, e"emplo si
tenemos0
int iXUH
(4
int "X--iH
entonces iXM y "XM.
!ost-decremento, representado por 'aria*le--, ue significa iXi-1, e"emplo si
tenemos0
int iXUH
int "Xi--H
entonces iXM y "XU.
&am*i/n estn asociadas algunas otras formas como0
iRXM ue significa iXiRMH
i-XT ue significa iXi-TH
i[XV ue significa iXi[VH
i:X2 ue significa iXi:2H
Es muy importante indicar ue el signo X, se conoce como asignacin y no corresponde a
igualdad.
Operadores $elacionales
Es igual, representado por el sm*olo XX.
8o es igual, representado por el sm*olo GX.
Es menor ue, representado por el sm*olo ].
En menor o igual ue, representado por el sm*olo ]X.
Es mayor ue, representado por el sm*olo ^.
Es mayor o igual ue, representado por el sm*olo ^X.
El resultado de la operacin reali%ada por los operadores relacionales arro"a como resultado
un 'alor *ooleano 2true o false3.
Operadores Condicionales
Lperador J, representado por __ y se utili%an para enla%ar 2unir3 operaciones con
operadores relacionales y su resultado esta dado por las ta*las de 'erdad.
(5
Lperador L, representado por `` y se utili%an para enla%ar 2unir3 operaciones con
operadores relacionales y su resultado esta dado por las ta*las de 'erdad.
E"emplo0 sean a y * dos operaciones relacionales su resultado depender del grado de
'erdad de cada e>presin y el resultado tam*i/n ser un *ooleano ue se desprender de la
ta*la respecti'a.
a * __ a * ``
A A A A A A
A # # A # A
# A # # A A
# # # # # #
@e las ta*las se desprende ue cuando analicemos un caso con el operador +y, solo
tendremos una respuesta 'erdadera si am*as e>presiones son 'erdaderas y en el caso del
operador +o, solo o*tendremos una respuesta falsa cuando am*as e>presiones lo sean.
todos
Ja conocemos las *ases 2el a*ecedario3 del lengua"e 4a'a, solo nos falta indicar ue cuando
escri*imos un m/todo, la idea es conocer un cierto comportamiento del o*"eto, esto
significa ue necesitamos ue el m/todo nos de'uel'a esta informacin, por lo cual a todo
m/todo se le antepone al nom*re, el tipo de dato ue de'ol'er y si no de'uel'e nada se
de*e colocar la pala*ra reser'ada +'oid,, adems, se de*e terminar el m/todo 2cuando
de'uel'e informacin3 con la pala*ra reser'ada +return, y entre par/ntesis redondos la
'aria*le ue contiene la informacin ue deseamos de'ol'er.
Analicemos un e"emplo para pro*ar y entender estas afirmaciones. !ensemos ue 'amos a
crear la clase .asa ue tiene como atri*utos el largo y el anc(o de la casa y como m/todo
los metros cuadrados ue esta tiene. Ja sa*emos y no (ay pro*lemas en las declaraciones
de los atri*utos pero con los m/todos la situacin no es la misma. Aeamos el pro*lema.
!rimero necesitamos sa*er 6cul es el pro*lema7, y este es determinar el rea de
una casa.
6.mo se reali%ara esto del punto de 'ista matemtico7 Esto se resuel'e
multiplicando el largo por el anc(o.
!osteriormente, de*emos de'ol'er el 'alor o*tenido.
(!
Lle'emos esto a(ora a cdigo.
Entonces, a(ora tenemos lista nuestra clase plano, la cual tiene dos atri*utos del tipo float
llamados largo y anc(o, adems cuenta con un m/todo llamado area@eLa.asa23 ue
de'uel'e un float ue representa la superficie ue tendr mi casa.
!or otra parte, 'emos ue esta clase construida solo es compila*le y si ueremos 'er los
resultados de*emos tener una clase adicional del tipo test o aplicacin 2ue contenga al
m/todo main3. El mecanismo para construir la clase aplicacin es similar a lo ue (icimos
para la clase donde 'imos el +(ola 4a'a,.
La imagen muestra la forma *sica ue tiene toda clase aplicacin, y a(ora de*emos 'er
cmo (acemos para tener acceso a 'er los datos ue nos interesan. Esta clase es
independiente de la clase plano ue construimos 2clase .asa3 por lo cual de*emos indicarle
al sistema ue usaremos la clase .asa para tra*a"ar esto se (ace creando un o*"eto de la
clase ue ueremos 'er, para ello se de*e indicar el tipo de o*"eto ue se crear 2.asa3
luego de*emos darle un nom*re al o*"eto y a este o*"eto asignarle mediante el operador
+ne;, una direccin de memoria donde de"ar el o*"eto0
(6
.asa nom*reNdelNo*"etoXne; .asa23H
A(ora para poder acceder a la informacin solo de*emos acceder a los atri*utos o m/todos
del o*"eto y esto se (ace mediante el operador punto 2.3. E"emplo0 si uiero o*tener el largo
de la casa de*o acceder0
nom*reNdelNo*"eto.largo
nom*reNdelNo*"eto.anc(o
nom*reNdelNo*"eto.area@eLa.asa23
Lle'emos esto al programa0
8uestro programa est listo a(ora podemos e"ecutarlo y el resultado es0
&area V
.onstruir una clase plano con sus respecti'as clases aplicacin para los siguientes sistemas0
!elota de radio M.M y m/todo 'olumen.
(-
.a"a de largo T y anc(o 2 con los m/todos rea y 'olumen.
Constructores
)i ueremos construir otro o*"eto de la clase .asa, el o*"eto tendr los mismos atri*utos,
con los mismos 'alores 2cantidades iguales3, por lo tanto nuestro sistema solo puede
construir casas de iguales dimensiones, a menos, ue ingresemos a la clase plano y
modifiuemos los 'alores de los atri*utos, la 'erdad es ue los programas no funcionan as,
y no de*en ser tan limitados. La solucin para esto, pasa por la utili%acin de un nue'o
m/todo llamado constructor, el ue tiene por funcin iniciali%ar los atri*utos del o*"eto
cuando /ste es creado. El m/todo constructor es un m/todo *astante particular, tiene como
nom*re el mismo ue la clase, es un m/todo ue no de'uel'e nada, pero, a pesar de esto no
se le antepone la pala*ra 'oid. La utili%acin de este m/todo significa ue ya no de*o
iniciali%ar manualmente mis atri*utos, por ende pueden aduirir cualuier 'alor. El m/todo
constructor siempre e>iste, cuando nosotros no lo escri*imos, el sistema lo crea y
corresponde a un constructor ue iniciali%a a los atri*utos en sus 'alores por defecto. Es
importante destacar, ue cuando nosotros escri*imos este constructor, el ue (a*a creado
el sistema, desaparece y se lo uiero de*o crearlo directamente. !ara compro*ar esto,
eliminemos de la clase .asa los 'alores de iniciali%acin y 'eamos los resultados, la clase
plano uedara0
J los resultados ue entrega de*eran ser los 'alores por defecto0
A(ora construiremos el nue'o constructor ue tiene por funcin iniciali%ar los atri*utos, en
/l se de*e indicar dentro de los par/ntesis redondos ue acompaOan al nom*re del m/todo
(#
el tipo y el nom*re de los datos ue se en'iaran desde el lugar donde se cree el o*"eto para
iniciali%ar los atri*utos. El orden ue se esta*le%ca para estos parmetros en el constructor
es ue se usara siempre, cuando se lo llame. @entro del constructor se de*en asignar los
parmetros ue traen la informacin a los respecti'os atri*utos. 1tili%ando la misma clase
anterior uedara0
@e*emos recordar, ue el constructor ue iniciali%a en los 'alores por defecto, ya no e>iste
y si lo necesito de*o crearlo de la siguiente manera0
2/
Es importante destacar ue los nom*re dados a los atri*utos y los nom*res de los
parmetros ue llegan por el constructor no de*en llamarse iguales porue induce a error al
sistema. !or e"emplo si nuestros atri*utos son largo y anc(o y los parmetros ue llegan por
el constructor se llamasen iguales, largo y anc(o, nos uedara0
.asa2float largo, float anc(o3
C
largoXlargoH
anc(oXanc(oH
I
El sistema al 'er esto, no sa*e cul es cual, si el primer largo es el atri*uto o el parmetro y
eso conducir a error. !or esto los nom*res de atri*utos y parmetros por a(ora de*ern ser
siempre distintos.
!or otra parte, a(ora cuando cree un o*"eto en la clase aplicacin, de*er/ en'iar los
parmetros necesarios para la iniciali%acin del o*"eto. Aeamos cmo se reali%a esto en la
clase aplicacin0
A(ora si creamos un segundo o*"eto podemos crearlo con las dimensiones ue deseemos, la
clase plano permite a(ora crear o*"etos de cualuier dimensin. El resultado de la e"ecucin
del programa a(ora muestra0
2(
odi%icadores de acceso
El lengua"e 4a'a se dice ue encapsula y protege la informacin, esto lo logra a tra'/s de
restringir los accesos a la informacin, mediante un indicador ue se antepone al tipo de
dato ya sea este de un atri*uto o el tipo de'uelto de un m/todo. Este indicador puede ser
pu*lic 2p-*lico3 o pr'ate 2pri'ado3, nosotros no (a*amos usado ninguno, cuando se omite,
el sistema lo asume como p-*lico por defecto ue es menos p-*lico ue el p-*lico escrito,
pero nunca tan restricti'o como el pr'ate. 8osotros solo tra*a"aremos de au en adelante
con atri*utos siempre pri'ados. Esto restringe el acceso a los datos protegi/ndolos.
A(ora para acceder a la informacin contenida en un atri*uto, si lo (ago mediante0
nom*reNdel No*"eto.atri*uto, el sistema de informara ue no puedo acceder a esta
informacin de esta manera porue ella es pri'ada. Aeamos primero como uedara
nuestra clase plano0
A(ora si compilamos la clase aplicacin 6u/ ocurre7, 'eamos0
22
El sistema me arro"a un error, en la lnea donde se trata de acceder por primera 'e% a la
informacin de los atri*utos y me dice ue el atri*uto largo es pri'ado y no puedo acceder
a /l.
todos accesadores " mutadores
!ara poder acceder a la informacin, ya sea para mostrarla o *ien para modificarla, de*o
(acerlo a tra'/s de m/todos creados especialmente para estas funciones. Estos m/todos 'an
integrados siem!re en los programas ue tienen sus atri*utos pri'ados. J se conocen como
m/todos accesadores o get 2los ue de'uel'en el contenido de los atri*utos3 y m/todos
mutadores o set 2los ue permiten modificar el contenido de los atri*utos3, y su forma
general es0
tipoNde'uelto get8om*reNdelNatri*uto230 esto para los m/todos accesadores, e"emplo para
la clase .asa0
float getLargo23
float getAnc(o23
Estos m/todos, tienen en su interior la de'olucin de la informacin contenida en el
atri*uto, e"emplo0
float getLargo23
C
return2largo3H
2)
I
'oid set8om*reNdelNatri*uto2tipoNnue'oN'alor parmetroNueNcontieneNnue'oN'alor30
esto para los m/todos mutadores, e"emplo para la clase .asa0
'oid setLargo2float nue'oNlargo3
'oid setAnc(o2float nue'oNanc(o3
Estos m/todos, tienen en su interior la modificacin de la informacin contenida por el
atri*uto. E"emplo0
'oid setLargo2float nue'oNlargo3
C
largoXnue'oNlargoH
I
.on todo esto nuestra clase .asa uedara de la siguiente forma0
24
J nuestra clase aplicacin, a(ora de*er utili%ar los nue'os m/todos ya sea para 'er o
modificar la informacin0
J el resultado de la e"ecucin del programa entregara0
Tarea "
.onstruir para la clase !elota y .a"a los constructores con parmetros, m/todos get y set y
su respecti'a clase aplicacin donde muestre sus atri*utos y e"ecucin de m/todos.
Ingreso de in%ormacin desde teclado
Ja estamos tra*a"ando con los atri*utos pri'ados, esto significa con m/todos get y set,
adems de los constructores con parmetros. )olo nos falta resol'er un pro*lema para ue
nuestro programa se acerue a la realidad de los programas 'erdaderos. Este pro*lema est
asociado al ingreso de informacin al programa, 6.mo ingresa uno informacin en los
programas7, normalmente el programa al e"ecutarse le solicita al usuario, +en forma clara,,
la informacin reuerida para ue el programa entregue los resultados *uscados, uno no
de*e a*rir el programa e ingresar manualmente los datos en su interior. !ara esto e>isten
25
'arias clases construida en 4a'a ue permiten (acer *astante simple este ingreso como la
clase )canner, la clase .onsola o la clase Leer. 8osotros en nuestro curso utili%aremos la
clase Leer, la cual consta de los siguientes m/todos ue nos permiten capturar desde
teclado la informacin reuerida0
!ara capturar s(ort se utili%a el m/todo dato.)(ort23.
!ara capturar int se utili%a el m/todo dato.Int23.
!ara capturar long se utili%a el m/todo dato.Long23.
!ara capturar float se utili%a el m/todo dato.#loat23.
!ara capturar dou*le se utili%a el m/todo dato.@ou*le23.
!ara capturar c(ar se utili%a el m/todo dato..(ar23.
!ara capturar )tring se utili%a el m/todo dato23.
Entonces si uisiera capturar, para la clase .asa, el largo, de*o en la clase aplicacin en'iar
un mensa"e a usuario indicndole ue ingrese el dato pertinente, capt-ralo con el m/todo
adecuado y entregarlo a una 'aria*le y luego continuo mi programa normalmente. Es
importante indicar ue la clase Leer de*e estar en la misma carpeta ue nuestra clase de
tra*a"o. Aeamos cmo ueda nuestra clase aplicacin con esta modificacin0
!ero primero, 6donde insertamos estas lneas7, la respuesta est asociada a ue ueremos
ue el sistema (aga0
1. 8ecesito ue el usuario me ingrese el largo y anc(o de la casa.
2. 6!ara u/ necesito el largo y anc(o7 Los necesito para poder crear el o*"eto, esto
significa ue de*o solicitar la informacin antes de crear el o*"eto.
T. 6@onde guardare la informacin ue ingrese el usuario7, de*er/ crear dos 'aria*les
para de"ar la informacin ingresada por el usuario. Esto significa ue despu/s de
crear las 'aria*les para guardar la informacin, de*er/ pedir los datos al usuario.
V. .onclusin. Las lneas ue de*emos incorporar 'an despu/s de la creacin de las
'aria*les y antes de la creacin del o*"eto.
2!
A(ora la pantalla de resultados cam*iar e interactuar con el usuario0
Aparecer esta frase y el cursor se uedara esperando el ingreso de los datos, una 'e%
ingresado el primer dato 2se finali%a el ingreso de este dato presionando enter3, 'uel'e a
parecer un mensa"e pero a(ora solicita el segundo dato, ingresado este, el sistema despliega
los resultados0
A(ora si estamos programando, ue de*o (acer si uiero construir simultneamente dos
casa, esto significa ue de*o construir 2 o*"etos del tipo .asa. !ara esto de*o duplicar lo
ue ya (e reali%ado cam*iando el nom*re para las 'aria*les del segundo o*"eto 2solo de*o
26
(acer los cam*ios en la clase aplicacin, ya ue la clase plano me descri*e cualuier
o*"eto3. Aeamos como uedara nuestra aplicacin0

J a(ora los resultados nos mostraran0
2-
@e la misma manera podramos crear un o*"eto tres y un cuatro, etc. !ero 'ol'amos a la
clase .asa pero con un solo o*"eto y 6Ku/ ocurrir si yo deseo modificar el largo de la
casa7
!rimero de*o pedir al usuario ue indiue en cuanto uiere modificar el largo de la
casa. Esto significa declarar una 'aria*le para capturar el 'alor y en'iar un mensa"e
adecuado al usuario para ue ingrese dic(o 'alor.
)egundo, 6donde coloco este mensa"e y la captura del 'alor7 La 'erdad es ue
de*era ir despu/s de crear el o*"eto y mostrar los resultados, para as tener una
forma de 'er los datos sin modificacin y con modificacin.
&ercero, 6cmo (ago la modificacin del atri*uto7 !ara esto de*emos recordar ue
tenemos construidos los m/todos set, ue permiten modificar los atri*utos del
o*"eto, y utili%ar el m/todo setLargo23 en'iando como parmetro el nue'o 'alor
ingresado por el usuario 2setlLargo2nue'oN'alor33.
#inalmente, de*o mostrar los resultados nue'amente para poder comparar.
Aeamos como uedara la clase aplicacin0
2#
@e la misma manera podemos, modificar el anc(o, recuerde ue modificar significa
cam*iar puede ser agrandar o disminuir una propiedad del o*"eto. J el resultado ue
tendremos es0
.uando uno (a*la de modificar una propiedad del atri*uto, esto puede ser0 cam*iarlo por
otro 'alor, aumentarlo o disminuirlo en un cierto 'alor, o aumentarlo o disminuirlo en un
cierto porcenta"e. Esto significa ue en cada caso, de*emos reali%ar algunos peueOos
cam*ios en la informacin ue en'iaremos como parmetro en el m/todo set0
)/
1. 9odificar completamente el atri*uto0 Esto significa ue reempla%aremos el nue'o
'alor por el antiguo. !or los tanto, solo de*emos en'iar el nue'o 'alor como
parmetro. E"emplo0 pensando en el anc(o de la casa.
float nue'oNanc(o, anc(oNaNen'iarH
)ystem.out.println2+Ingrese el nue'o anc(o,3H
nue'oNanc(oXLeer.dato#loat23H
anc(oNaNen'iarXnue'oNanc(oH
o*"etoNuno.setAnc(o2anc(oNaNen'iar3H
2. 9odificar aumentando 2o disminuyendo3 en una cierta cantidad el atri*uto. Esto
significa ue de*emos agregar a lo ue tenemos el 'alor ingresado y esta suma es
lo ue de*emos en'iar como parmetro.
float incremento, anc(oNaNen'iarH
)ystem.out.println2+Ingrese cantidad a aumentar el anc(o,3H
incrementoXLeer.dato#loat23H
anc(oNaNen'iarXo*"etoNuno.getAnc(o23RincrementoH
T. 9odificar aumentado 2o disminuyendo3 en un cierto porcenta"e el atri*uto. Esto
significa ue lo ue tengo es el 100 por ciento a lo cual de*o agregarle la cantidad
ue representa el porcenta"e ingresado por el usuario y en'iar este nue'o 'alor.
float incremento, anc(oNaNen'iarH
)ystem.out.println2+Ingrese porcenta"e a aumentar el anc(o,3H
incrementoXLeer.dato#loat23H
anc(oNaNen'iarXo*"etoNuno.getAnc(o23R2o*"etoNuno.getAnc(o23[incremento3:100H
En este -ltimo caso, de*emos asumir ue normalmente el usuario ingresara el
porcenta"e solicitado, esto es 12,U o 2W,T etc. y no ingresara el porcenta"e como 0,12U o
0,2WT 2tanto por 13.
Casteo o moldeo de valores
E>isten situaciones donde tenemos 'alores de distinto tipo 2enteros y reales3 me%clados
y en estos casos el sistema mantiene el formato de mayor precisin en otras pala*ras si
tenemos float y dou*le o int y dou*le, etc. el sistema pri'ilegiara al dou*le y el
resultado ue entregara ser dou*le pero (ay oportunidades donde se necesita ue el
resultado sea o float o int, etc. entonces se de*e castear o moldear este resultado, esto
significa ue de*emos for%ar al sistema al tipo de dato ue ueremos y esto se (ace0
)upongamos ue tenemos0 int >, int aXT,dou*le *XT.2, float (X2,Wf, float pH
>X2int32aR*3H
)(
pX2float32*[(Ra3H
Es importante destacar ue se de*e encerrar entre par/ntesis a la e>presin matemtica
completa no solo al n-mero en cuestin ni al resultado ya ue el casteo no apro>ima
sino ue corta el n-mero de acuerdo con su precisin.
#ocumentacin de los programas
En los programas anteriores se puede 'er la utili%acin del +::, este sm*olo se usa para
colocar comentarios de lneas, esto significa ue el te>to ue se coloue a continuacin
del sm*olo no ser compilado porue es un comentario 2informacin solo pertinente
para el programador3.
&am*i/n e>isten comentarios de *loue los ue se encierran de la siguiente manera0
:[comentario de *loue
[donde uno coloca el te>to
[e>plicati'o ue desee y no
[compila*le y de*e cerrarse con esto
[:
Adems e>iste un comentario llamado de documentacin el cual permite mediante el
programa 4a'adoc construir la A!I del programa. La A!I es un documento
estandari%ado para la descripcin de las clases, donde 'i'en, ue m/todos tienen, ue
de'uel'en y ue (acen estos m/todos, etc. !ara utili%ar este 4a'adoc en forma directa o
a tra'/s de un I@E es necesario esta*lecer dentro del programa y antes de cada m/todo
el comentario de documentacin adecuado utili%ando el siguiente formato0
::[comentario de documentacin
[para un m/todo
[o para lo ue uno
[desee documentar
[:
1na 'e% insertados estos comentarios en el programa, este se compila y se de*e e"ecutar
el 4a'adoc, ya sea directamente desde la carpeta de 4a'a o mediante el I@E y se o*tiene
un documento parecido a este0
)2
@onde se puede apreciar ue aparece toda la informacin de la clase L*"ect, ue es la
primera clase de 4a'a, sus m/todos, desde ue 'ersin e>iste, donde 'i'e, etc.
Esta forma de documentar los programas es muy importante en la construccin de
sistemas de informacin, ya ue permite a cualuier programador entender y reutili%ar
las clases ya construidas por otros programadores.
E"ercicio de repaso 10
.onstruir una clase llamada Leon ue tiene los siguientes atri*utos0 edad 2entero3, peso
y largo 2dou*le3. J los siguientes m/todos0 .onstructores, accesadores y mutadores
adems de los siguientes m/todos customer0
comer230 Este m/todo modificara el peso del len aumentndolo en un T,M\ y
modificara el largo del len aumentndolo en un 0,1.
ca%ar230 Este m/todo modificara el peso del len disminuy/ndolo en un 0,V2\ y
aumentara la edad en 1.
dormir230 Este m/todo modificara la edad del len aumentndola en 2 y
disminuir su peso en un 0,2T\.
.onstruya adicionalmente una clase aplicacin donde cree dos leones y pueda 'er sus
atri*utos iniciales y despu/s de comer, dormir y ca%ar. 9odifiue 2aumentado3 la edad
del len uno en un 'alor ingresado por el usuario y cam*ie la edad del len dos por un
nue'o 'alor ingresado por el usuario. 9odifiue el peso del len 1 en un porcenta"e
dado por el usuario 2disminuyendo3. 9uestre los resultados finales.
@esarrollo
1. En primer lugar de*emos anali%ar, nom*re y tipos de datos ue contendrn los
atri*utos. @e*emos tener claro ue su ni'el de acceso de*e ser pri'ado y los nom*re
ms lgicos son edad 2del tipo int3, largo y peso 2del tipo dou*le3.
))
2. Los constructores de la clase de*en ser dos el 'acio 2ue iniciali%a los atri*utos en
los 'alores por defecto3 y el constructor con parmetro 2ue de*er reci*ir la edad,
el peso y el largo, para asignarle el 'alor respecti'o a los atri*utos3.
T. Los m/todos o*ligados, cuando los atri*utos son pri'ados, son los accesadores y
mutadores para cada atri*uto.
V. )iempre el pro*lema se presentara en la construccin de los m/todos customer, en
este caso son tres. Aeamos el primero de ellos0
a. 9/todo comer23, la primera pregunta ue de*emos (acernos es 6Ku/
de'uel'e el m/todo7 )i leemos detenidamente la descripcin del m/todo,
o*ser'amos ue no se indica ue de'uel'a algo, sino ue solo modifica. !or
lo tanto el m/todo no de'uel'e nada, esto significa ue de*e lle'ar como
tipo de'uelto la pala*ra +'oid,. !or otra parte la descripcin del m/todo
indica ue aumenta el peso y el largo simultneamente, esto significa ue
cada 'e% ue el m/todo act-e 2sea llamado3 (ar crecer am*os atri*utos en
los 'alores indicados. 6.mo podemos descri*ir este comportamiento7
&enemos dos opciones, la ms simple es recordar ue (emos construido
m/todos capaces de modificar los atri*utos, por los cual podramos al
interior de este m/todo llamar a los respecti'os m/todos y as producir la
modificacin de los atri*utos. L *ien construir al interior del m/todo la
modificacin de los atri*utos 2lo ue tienen en su interior los m/todos set3.
@e*emos tener en cuenta ue para la modificacin del peso es en porcenta"e,
pero para la modificacin del largo solo es en un 'alor. En este m/todo,
usaremos la llamada a los m/todos set respecti'os.
*. 9/todo ca%ar23, el ra%onamiento es similar, pero para t/rminos del
aprendi%a"e usaremos au la construccin de la modificacin de los
atri*utos.
c. 9/todo dormir23, igual a los anteriores pero nue'amente usaremos la
llamada a los m/todos set, ya construidos.
:[[ Au se colocan los comentarios ue
[cuentan ue (ace la clase
[:
class Leon
C
pri'ate dou*le largo,pesoH //atributos reales
pri'ate int edadH //atributo entero
:[[Au 'an los comentarios de ue caractersticas
[tiene el constructor
[:
Leon2int ed,dou*le lar,dou*le pe3 //constructor con parametros
C
edadXedH
largoXlarH
pesoXpeH
I
:[[Au 'an los comentarios
[so*re el constructor 'acio
[o por defecto
)4
[:
Leon23 //constructor por defecto
C
I
:[[Au 'an los comentarios so*re
[el m/todo getEdad y asi sucesi'amente
[:
int getEdad23 //metodos get o accesadores
C
return2edad3H
I
dou*le getLargo23
C
return2largo3H
I
dou*le get!eso23
C
return2peso3H
I
'oid setEdad2int nue'aNedad3 //metodos set o mutadores
C
edadXnue'aNedadH
I
'oid set!eso2dou*le nue'oNpeso3
C
pesoXnue'oNpesoH
I
'oid setLargo2dou*le nue'oNlargo3
C
largoXnue'oNlargoH
I
'oid comer23 //metodo customer donde se sabe que el peso aumenta ,!" y el largo en #,$
C
dou*le nue'oNpeso,nue'oNlargoH // se crean dos %ariables para guardar la modificacion
nue'oNpesoXpesoRpeso[T.M:100H
set!eso2nue'oNpeso3H //se hace la modificacion
nue'oNlargoXlargoR0.1H
setLargo2nue'oNlargo3H
I
'oid ca%ar23 //metodo customer donde se sabe que el peso disminuye #,&'" y la edad aumenta en $
C
pesoXpeso-peso[0.V2:100H //se hace directamente la modificacion sobre el atributo
edadXedadR1H
I
'oid dormir23 ::metodo customer donde se sabe que aumenta la edad en ' y disminuye el peso en #,'"
C
dou*le nue'oNpesoH
int nue'aNedadH
nue'oNpesoXpeso-peso[0.2T:100H
set!eso2nue'oNpeso3H
nue'aNedadXedadR2H
setEdad2nue'aNedad3H
I
I
M. A(ora de*emos construir nuestra aplicacin para poder e"ecutar nuestro programa.
La aplicacin en primer lugar de*er contener el m/todo main y en su interior
declararemos las 'aria*les ue necesitamos para tra*a"ar, luego solicitamos la
informacin necesaria al usuario, guardando la informacin en las 'aria*les
respecti'as y construimos el o*"eto. A(ora podemos mostrar los resultados del
)5
o*"eto y proceder a e"ecutar m/todos ya sea para mostrar resultados o (acer
modificaciones so*re los atri*utos. )i 'emos nuestra clase Leon, necesitamos para
construir uno, la edad, el peso y el largo pero como son dos necesitamos el do*le de
'aria*les y tam*i/n necesitamos 'aria*les para mostrar los datos, tam*i/n de los
dos o*"etos y para modificar la edad de am*os o*"etos y para modificar en
porcenta"e el peso del leon1. Lle'emos esto a cdigo0
class AppLeon
C
pu*lic static 'oid main2)tringDEarg3
C
::declaracion de %ariables para los dos objetos y para mostrar los resultados
dou*le largo1,largo2,peso1,peso2,mostrarNlargo1,mostrarNlargo2,mostrarNpeso1,mostrarNpeso2,modificaNpeso1H
int edad1,edad2,mostrarNedad1,mostrarNedad2,modificaNedad1,modificaNedad2H
//solicito la informacion para crear el objeto$
)ystem.out.println2FIngrese la edad del Leon 1F3H
edad1XLeer.datoInt23H
)ystem.out.println2FIngrese el peso del Leon 1F3H
peso1XLeer.dato@ou*le23H
)ystem.out.println2FIngrese el largo del Leon 1F3H
largo1XLeer.dato@ou*le23H
//ahora podemos crear el objeto$, debemos recordar el orden del constructor
//(eon)int ed,double lar,double pe*
Leon unoXne; Leon2edad1,largo1,peso13H //objeto creado
//+eali,amos lo mismo para el objeto'
//solicito la informacion para crear el objeto'
)ystem.out.println2FIngrese la edad del Leon 2F3H
edad2XLeer.datoInt23H
)ystem.out.println2FIngrese el peso del Leon 2F3H
peso2XLeer.dato@ou*le23H
)ystem.out.println2FIngrese el largo del Leon 2F3H
largo2XLeer.dato@ou*le23H
//ahora podemos crear el objeto$, debemos recordar el orden del constructor
//(eon)int ed,double lar,double pe*
Leon dosXne; Leon2edad2,largo2,peso23H //objeto creado
//-hora podemos mostrar a los objetos creados
mostrarNlargo1Xuno.getLargo23H
mostrarNpeso1Xuno.get!eso23H
mostrarNedad1Xuno.getEdad23H
mostrarNlargo2Xdos.getLargo23H
mostrarNpeso2Xdos.get!eso23H
mostrarNedad2Xdos.getEdad23H
)ystem.out.println2FEl leon1 tienen una edad de0 FRmostrarNedad1RF y un peso de0 FRmostrarNpeso1RF y un largo de0
FRmostrarNlargo13H
FRmostrarNlargo23H
I
I
Basta au, solo (emos creado los 2 o*"etos solicitados y mostrado el contenido de ellos. )i
e"ecutamos esta parte tenemos0
)!
Agreguemos el cdigo ue nos falta para e"ecutar los m/todos creados, comer, ca%ar y
dormir y 'ol'amos a mostrar los resultados 2estos se agrega a continuacin de los
)ystem.out.println ue muestran los o*"etos30
//ejecutando los metodos ca,ar, comer y dormir
uno.ca%ar23H
uno.comer23H
uno.dormir23H
dos.ca%ar23H
dos.comer23H
dos.dormir23H
//.ara poder %er como han cambiado los objetos debemos llamar a los metodos que de%uel%en sus atributos
//-hora podemos %er nue%amente los objetos
FRmostrarNlargo13H
FRmostrarNlargo23H
I
I
Estamos listos para 'er como los o*"etos cam*ian cuando se e"ecutan los m/todos ca%ar,
comer y dormir. J la pantalla nos entrega los siguientes resultados0
)6
)olo nos falta reali%ar las -ltimas modificaciones solicitadas en el e"ercicio, para esto
de*emos agregar el cdigo a despu/s de los )ystem.out.println ue muestran los o*"etos.
=ecordar ue se tiene ue pedir al usuario0
El 'alor en ue se aumentara la edad del len uno.
El 'alor por el cual se reempla%ara la edad del len dos.
J el porcenta"e en el cual se disminuir el peso del leon1.
#inalmente, terminaremos el programa llamando a los m/todos ue nos de'uel'en los
'alores contenidos en los atri*utos y mostrndolos. El -ltimo cdigo entonces ser0
///olicitamos al usuario los %alores que modifican
)ystem.out.println2FIngrese el 'alor en ue aumentara la edad del leon1F3H
modificaNedad1XLeer.datoInt23H
)ystem.out.println2FIngrese el 'alor ue reempla%ara la edad del leon2F3H
modificaNedad2XLeer.datoInt23H
)ystem.out.println2FIngrese el porcenta"e en ue disminuira el peso del leon1F3H
modificaNpeso1XLeer.datoInt23H
//reali,amos las modificaciones
int nue'oN'alorXuno.getEdad23RmodificaNedad1H
uno.setEdad2nue'oN'alor3H
dos.setEdad2modificaNedad23H
dou*le nue'oNpesoXuno.get!eso23-uno.get!eso23[modificaNpeso1:100H
uno.set!eso2nue'oNpeso3H
//.ara poder %er como han cambiado los objetos debemos llamar a los metodos que de%uel%en sus atributos
//-hora podemos %er nue%amente los objetos
FRmostrarNlargo13H
FRmostrarNlargo23H
I
I
)-
E"ercicio de repaso 20
El faran =ams/s II, necesita un sistema para la construccin de sus pirmides de *ase
rectangular, ue le entregue la cantidad de piedra necesaria 2en metros cu*icos3 y el tiempo
ue se demoraran en su construccin y el peso ue ella tendr.
El matemtico del reino (a entregado la siguiente relacin para el clculo del
'olumen de la pirmide0 largo de la base # ancho de la base # altura # 1$%
El aruitecto del reino indica ue de*e considerarse la pirmide como totalmente
solida y ue un *loue de un metro cu*ico pesa M toneladas 2M000 ?ilos3
El constructor del reino informa ue se tienen 1200 tra*a"adores disponi*les y ue
100 tra*a"adores se demoran V2 das en cortar, trasladar y montar un *loue de 1
metro cu*ico.
@esarrollo.
1. 6.ules son nuestros atri*utos y de u/ tipo7 !ara construir una pirmide
necesitamos contar con largo de la *ase, anc(o de la *ase y altura, los cuales
de*eran ser reales 2float o dou*le3. 6!or u/ no son atri*utos el tiempo de
construccin o la cantidad de piedra necesaria7 @e*ido a ue estos 'alores son los
ue se necesitan conocer y se o*tendrn como resultados de algunas operaciones
matemticas ue se reali%aran so*re los atri*utos. 6J el n-mero de tra*a"adores7 Es
un dato dado.
2. 6Ku/ m/todos de*o construir7 Los constructores 2'acio o por defecto y con
parmetros. $et y set correspondientes.
T. 6.ules y como construyo los m/todos customer7 !ara la construccin de ellos
de*emos anali%ar ue se pretende ue entregue el programa y desde a(
o*tendremos la respuesta a esta pregunta0
a. .antidad de piedra necesaria 2en metros c-*icos3, esto es el 'olumen ue
tendr la pirmide, por los cual un m/todo customer de*e ser el 'olumen de
la pirmide. Este m/todo de*er de'ol'er el 'olumen 2un real3 y para su
construccin declararemos una 'aria*le real, donde de"aremos el resultado,
esto es, el total de la operatoria de la formula de 'olumen de una pirmide y
de'ol'eremos este 'alor 2return3.
*. !eso de la pirmide, esto se determina sa*iendo cunto pesa un metro cu*ico
y por el 'olumen podemos determinar el peso total de la estructura. &am*i/n
este ser un m/todo customer. Ac tam*i/n de*emos declarar una 'aria*le
real donde de"aremos el resultado de la operatoria 2>3. 6.ul operatoria7
Esta es una regla de tres simple 2proporcin3 donde se sa*e ue un metro
cu*ico pesa M000 ?ilos por lo tanto el peso de nuestro 'olumen 2pirmide3
)#
pesara un > 2incgnita3, si despe"amos esta incgnita o*tendremos >X
M000['olumen de la pirmide. Aalor ue de'ol'eremos 2return3.
c. &iempo de construccin, se conoce cuanto se demoran 100 tra*a"adores en
construir, trasladar y montar un *loue de 1 metro cu*ico, por lo tanto
conociendo el 'olumen podemos determinar para el n-mero de tra*a"adores
dado 212003, el tiempo. Este ser el -ltimo m/todo customer. &am*i/n
declaramos 'aria*les 2en esta caso 23 donde de"aremos los resultado de
nuestra operatoria la cual es similar al caso anterior, una proporcin donde
se sa*e ue 100 tra*a"adores se demoran V2 das en 1 metro cu*ico, entonces
1200 se de*eran demorar muc(o menos 2es importante indicar ue au
estamos frente a una proporcin in'ersa3, donde >XV2[100:1200. A(ora este
'alor es el tiempo en 1 metro cu*ico por lo tanto en 'olumen ue tenemos se
demoraran y, donde yX>['olumen de la pirmide.
V. @e*emos adems construir una aplicacin donde declaremos las 'aria*les ue
necesitamos tanto para crear el o*"eto como para mostrar los resultados, luego en
esta aplicacin de*emos crear el o*"eto y llamar a los m/todos para poder mostrar
los resultados reueridos.
Lle'emos a(ora esto a cdigo y tendremos0
class !iramide
C
pri'ate dou*le largo,anc(o,alturaH

!iramide2dou*le lar,dou*le anc,dou*le alt3
C
largoXlarH
anc(oXancH
alturaXaltH
I
!iramide23
C
I
dou*le getLargo23
C
return2largo3H
I
dou*le getAnc(o23
C
return2anc(o3H
I
dou*le getAltura23
C
return2altura3H
I
'oid setLargo2dou*le nue'oNlargo3
C
largoXnue'oNlargoH
I
'oid setAnc(o2dou*le nue'oNanc(o3
C
4/
anc(oXnue'oNanc(oH
I
'oid setAltura2dou*le nue'aNaltura3
C
alturaXnue'aNalturaH
I
dou*le 'olumen23
C
dou*le 'H
'Xanc(o[largo[altura:TH
return2'3H
I
dou*le peso!iramide23
C
dou*le >H
>XM000['olumen23H
return2>3H
I
dou*le tiempo.onstruccion23
C
dou*le >,yH
>XV2[100:1200H
yX>['olumen23H
return2y3H
I
I
J nuestra aplicacin se con'ierte en0
class App!iramide
C
C
dou*le largo,anc(o,alto,mlargo,manc(o,malto,peso,tiempo,piedraH
)ystem.out.println2FIngrese largo de la piramideF3H
largoXLeer.dato@ou*le23H
)ystem.out.println2FIngrese anc(o de la piramideF3H
anc(oXLeer.dato@ou*le23H
)ystem.out.println2FIngrese altura de la piramideF3H
altoXLeer.dato@ou*le23H
!iramide unoXne; !iramide2largo,anc(o,alto3H
mlargoXuno.getLargo23H
manc(oXuno.getAnc(o23H
maltoXuno.getAltura23H
piedraXuno.'olumen23H
pesoXuno.peso!iramide23H
tiempoXuno.tiempo.onstruccion23H
)ystem.out.println2FLa piramide de0 FRmlargoRF de largo y FRmanc(oRF de anc(o y FRmaltoRF de alturaF3H
)ystem.out.println2FLcuapa0 FRpiedraRF metros cu*icos de piedraF3H
)ystem.out.println2FJ pesa0 FRpesoRF ?ilosF3H
)ystem.out.println2FJ su construccion se demorara0 FRtiempoRF diasF3H
I
I
J los resultados son0
4(
La clase at&
El lengua"e 4a'a entre sus cualidades presenta la reutili%acin del cdigo, esto significa
entre otras cosas, no 'ol'er a construir lo ue ya est (ec(o, para esto es importante sa*er
ue est (ec(o en este lengua"e, por ello es importante conocer las A!I de 4a'a, las ue
corresponden a la documentacin de las clases construidas por la )18 donde se indica
donde residen estas clases, los nom*re de los m/todos y como utili%arlos. A(ora
ingresemos al google y colouemos0 +api 4a'a,, el sistema nos desplegara 'arios aciertos
pero generalmente el primero de ellos es el asociado a la )18 y la 'ersin ms nue'a de
4a'a 2M.03, si ingresamos en este se desplegara0
En el costado i%uierdo superior, aparecen los diferentes pauetes y en la parte inferior las
clases ue componen el pauete y si se selecciona una clase su api se despliega en el centro.
)eleccionemos el pauete 4a'a.lang ue corresponde al pauete *ase donde corre
normalmente 4a'a y seleccionemos la clase 9at(, se desplegara la api de esta clase donde
se indica ue esta clase contiene m/todos matemticos para la manipulacin de 'alores,
donde los m/todos principales son0
log(double a)
,eturns t0e natural logarit0m 3base e4 o. a double value.
42
log10(double a)
,eturns t0e base (/ logarit0m o. a double value.
max(double a,double b)
,eturns t0e greater o. t2o double values.
min(double a,double b)
,eturns t0e smaller o. t2o double values.
pow(double a,double b)
,eturns t0e value o. t0e .irst argument raised to t0e po2er o. t0e second argument.
random()
,eturns a double value 2it0 a positive sign: greater t0an or e;ual to 0.0 and less
t0an 1.0.
sqrt(double a)
,eturns t0e correctl* rounded positive s;uare root o. a double value.
!ara utili%ar estos m/todos se de*e al igual ue la clase Leer llamarlos mediante la clase,
por e"emplo si uiero e>traer ra% cuadrada de 'X2.SQH
(X9at(.srt2'3 o si se uiere ele'ar este mismo n-mero a la M potenciaH
gX9at(.po;2',M3H
E"ercicios propuestos0
E&ercicio 1
.onstruir una clase llamada Aideo.lu*, ue tiene por atri*utos0
.digo de la pelcula
@uracin de la pelcula
Aalor del arriendo
.opias
J los siguientes m/todos0
9/todo ue de'uel'e el 'alor a pagar por el arriendo 2el i'a es el 1W\3
9/todo ue de'uel'e cuantos minutos de pelcula se tiene y ue corresponde al producto del n-mero de
copias por la duracin.
.onstruir una aplicacin ue permita crear T o*"etos del tipo Aideo.lu* y utili%ar los m/todos,
mostrando0
L*"eto 'alor a pagar duracin'alor copias minutos totales
1 >>>>> >>>> >>>> >>>> >>>>
2 >>>>> >>>> >>>> >>>> >>>>
T >>>>> >>>> >>>> >>>> >>>>
Luego disminuya la duracin de la pelcula y aumente el 'alor del arriendo, 'uel'a a mostrar0
L*"eto 'alor a pagar duracin'alor copias minutos totales
1 >>>>> >>>> >>>> >>>> >>>>
2 >>>>> >>>> >>>> >>>> >>>>
T >>>>> >>>> >>>> >>>> >>>>
4)
E&ercicio 2
1. .rear una clase llamada .irculo la cual tendr como atri*uto el radio del .irculo y los siguientes
m/todos0
a. area230 de'ol'er el rea del .irculo
*. perimetro230 de'ol'er el permetro del .irculo
c. constructores, get y set.
2. =eali%ar una aplicacin ue permita crear T o*"etos de tipo .irculo 2con 'alores ingresados por el
usuario3 y luego0
a. 9ostrar la informacin de cada o*"eto de la siguiente forma0
.irculo =adio area !ermetro
1 ---- ----- ------
2 ---- ----- ------
T ---- ----- ------
*. Aumentar el radio del .irculo 1 y T
c. 9ostrar nue'amente la informacin0
.irculo =adio area !ermetro
1 ---- ----- ------
2 ---- ----- ------
T ---- ----- ------
E&ercicio
.onstruir una clase llamada !iscina, ue tiene por atri*utos0
largo
anc(o
profundidad
J los siguientes m/todos0
9/todo ue de'uel'e el la cantidad de agua necesaria para llenar la piscina.
9/todo ue de'uel'e cuantos litros de pintura se necesitan para pintarla sa*iendo ue 2 metros
cuadrados de superficie se pintan con 1 litro.
.onstructores y m/todos set y get.
.onstruir una aplicacin ue permita crear T o*"etos del tipo !iscina y utili%ar los m/todos, mostrando0
L*"eto agua pintura largo anc(o profundidad
1 >>>>> >>>> >>>> >>>> >>>>
2 >>>>> >>>> >>>> >>>> >>>>
T >>>>> >>>> >>>> >>>> >>>>
Luego disminuya la profundidad en un 12,V\ para el o*"eto 1 y aumente el largo en medio metro para el
o*"etoT, 'uel'a a mostrar0
L*"eto agua pintura largo anc(o profundidad
1 >>>>> >>>> >>>> >>>> >>>>
44
2 >>>>> >>>> >>>> >>>> >>>>
T >>>>> >>>> >>>> >>>> >>>>
E&ercicio '
1. .rear una clase llamada .alculadora la cual tendr como atri*utos a num1 y num2 2n-meros enteros3
y los como m/todos las cuatro operaciones *sicas 2sumar, restar, multiplicar y di'idir3 y adems de
los constructores y m/todos get y set.
2. =eali%ar una aplicacin ue permita crear 2 o*"etos de tipo .alculadora 2con 'alores ingresados por
el usuario3 y luego0
a. 9ostrar la informacin de cada o*"eto de la siguiente forma0
.alculadora num1 num2 )uma =esta 9ultiplicacin @i'isin
1 ---- ----- ---- ---- ------- -----
2 ---- ----- ---- ---- ------- -----
*. Aumentar el atri*uto num2 en T al primer o*"eto
c. @ecrementar el atri*uto num1 en 2 al segundo o*"eto
d. 9ostrar nue'amente la informacin0
.alculadora num1 num2 )uma =esta 9ultiplicacin @i'isin
1 ---- ----- ---- ---- ------- -----
2 ---- ----- ---- ---- ------- -----
E&ercicio "
.onstruir una clase llamada Alumno ue tiene por atri*utos0
8om*re, rut, fono, edad, nota1, nota2 notaT.
J los siguientes m/todos customer0
i3 promedio23 este m/todo de'uel'e el promedio del alumno sa*iendo ue la nota1 'ale 20\,
la nota2 T0\ y la notaT un M0\ del promedio.
ii3 nota8ecesaria23 m/todo ue de'uel'e la nota ue necesita el alumno en el e>amen para
apro*ar el curso 2T,WM3, sa*iendo ue la nota del e>amen 'ale un V0\ de la nota final y el
resto est dado por el promedio o*tenido por el alumno.
.onstruir adems los m/todos accesadores, constructores y mutadores.
.onstruir una aplicacin donde se construyan T o*"etos y muestre toda su informacin 2nom*re, rut,
fono, edad, nota1, nota2, notaT, promedio, nota necesaria3
Luego en el o*"eto 1 modifiue el nom*re y el rut por uno nue'o. En el o*"eto 2 aumente la edad en
dos y el el o*"eto T disminuya la nota 2 en un 1M,TT\. 9uestre nue'amente los resultados.
'entencias de control
La informacin dentro de un programa fluye en su interior, como el agua desde los cerros
(acia el mar. La informacin se solicita y pasa a los constructores para iniciali%ar los
atri*utos, posteriormente fluye en distintos m/todos en la medida en ue estos son
45
llamados, para finalmente entregar los resultados. E>isten oportunidades donde la
informacin se enfrenta a una *ifurcacin 22 opciones de camino3 y el sistema de*e ser
capa% de indicar u/ camino tomar seg-n sean las condiciones presentes, en esta situacin
estamos presente a una sentencia condicional.
'entencias condicionales
.uando un alumno o*tiene T,WM o ms de promedio final, est apro*ado, en cam*io cuando
su promedio es inferior a este 'alor, esta repro*ado, esto lo podemos plantear de otra forma,
podemos decir ue si la nota promedio es mayor o igual a T,WM el alumno esta apro*ado
sino esta repro*ado. Au est presente nuestra primera sentencia condicional conocida
como +)i, la cual en esta situacin est acompaOada por un +)ino,.
En el lengua"e 4a'a esta sentencia 2)I3 se conoce como +if, y siempre 'a acompaOada de
una e>presin *ooleana entre par/ntesis redondos, seg-n0
if2nota^XT.WM3
C
c0digo que indica que debe hacer el programa cuando esta
condici0n es %erdadera
I
La e>presin +nota^XT.WM, es una e>presin *ooleana, ya ue solo puede tomar el 'alor
'erdadero o falso, solo dependiendo del 'alor ue tenga la 'aria*le nota. &am*i/n se puede
o*ser'ar ue luego del if se a*re un *loue dentro del cual se coloca lo ue se desea ue el
sistema (aga cuando la sentencia condicional sea 'erdadera 2entre en el *loue3, si despu/s
de e'aluar el grado de 'erdad de la sentencia condicional se encuentra ue esta es falsa el
sistema se salta la sentencia continuando con la lnea a continuacin del fin del *loue if.
@entro de un *loue if puede colocarse otro *loue if y dentro de este otro y as
sucesi'amente sin lmite. &am*i/n a continuacin de un *loue if puede colocarse otro y a
continuacin otro y otro infinitamente. E"emplo0
if2condicion13
C
if2condicion23
C
if2condicionT3
C
if2condicionV3
C
if2condicionM3
C
I
I
I
I
I
E'identemente, cada *loue de*e ir cerrado y en su interior se indicara ue se desea ue el
sistema realice cuando se cumpla la condicin. &am*i/n podemos tener0
if2condicion13
4!
C
I
if2condicion23
C
I
if2condicionT3
C
I
if2condicionV3
C
I
if2condicionM3
C
I
La sentencia condicional if, puede adems contar con ms de una condicin pero estas
condiciones de*en ir enla%adas 2unidas3 mediante los operadores +J, u +L, y su resultado
final 2*ooleano3 estar regido por las ta*las de 'erdad correspondientes. !or e"emplo si
tenemos la 'aria*le nota y asistencia, se necesita para apro*ar un T,WM o ms ( contar con
un SM\ de asistencia o ms, esto uedara refle"ado seg-n0
if2nota^XT.WM__asistencia^XSM3
C
I
@e*emos recordar ue solo se ingresara a este *loue cuando am*as condiciones se
cumplan simultneamente.
!odemos colocar todas las condiciones ue ueramos en la condicin del if, siempre y
cuando las unamos mediantes y 2__3 u o2``3.
!or otra parte, la sentencia si 2if3 tiene un complemento, el sino 2else3, complemento
significa ue a*arcara todo el resto, todo lo ue no a*arca el si, lo cu*re el sino. Aol'iendo
a la 'aria*le nota, si esta no es mayor o igual a T,WM 6ue pasa con el programa7 Ja ue no
entrara al *loue if, entonces es *ueno descri*ir un nue'o *loue llamado else en el cual
indicaremos ue (acer en el caso de ue el if no se cumpla.
if2nota^XT.WM3
C
I
else
C
c0digo que indica que debe hacer el programa cuando la
condici0n del if es falsa
I
Es importante notar ue el else nunca lle'a condicin, ya ue la condicin uedo
esta*lecida en el if 2el else es un complemento del if3. La sentencia else es opcional, si
46
uiero la incluyo, si me con'iene. 8o puede ir sola de*e e>istir siempre antes de un else un
if. @entro de un *loue else puede ir un if el cual puede tam*i/n lle'ar un else, el cual a su
'e% puede tam*i/n en su interior lle'ar un if y asi sucesi'amente. En la utili%acin del else,
de*e siempre tenerse en cuenta ue todo lo ue no entra en el if entrara en else. !or
e"emplo si deseamos separar los n-meros positi'os y negati'os podramos decir0
if2numero^03
C
-qu dejo a todos los positi%os
I
else
C
I
6Kue estamos de"ando en el else7 E'identemente a todos los negati'os, pero o"o, porue
tam*i/n (emos incluido al cero.
.onstruyamos un programa ue nos permita tra*a"ar con esta nue'a sentencia0
.onstruir una clase llamada Alumno, ue tiene como atri*utos0 nota1, nota2 y notaT y los
m/todos get, set, constructores y los siguientes customer0
promedio230 m/todo ue de'ol'er el promedio del alumno considerando ue todas
las notas 'alen lo mismo.
situacin230 m/todo ue de'ol'er una letra A si el alumno esta apro*ado sino
de'ol'er una =.
@esarrollo0
8uestros atri*utos son las notas, las cuales son reales y de*en ser pri'adas, por esto mismo
de*emos contar con un m/todo accesador y un mutador para cada nota. !ara la
iniciali%acin de nuestros o*"etos necesitamos los constructores, 'acio y con parmetros.
class Alumno
C
pri'ate dou*le nota1,nota2,notaTH

Alumno2dou*le n1,dou*le n2,dou*le nT3
C
nota1Xn1H
nota2Xn2H
notaTXnTH
I
Alumno23
C
I
dou*le get8ota123
C
return2nota13H
I
dou*le get8ota223
C
return2nota23H
I
dou*le get8otaT23
C
return2notaT3H
I
4-
'oid set8ota12dou*le nue'aNnota13
C
nota1Xnue'aNnota1H
I
'oid set8ota22dou*le nue'aNnota23
C
nota2Xnue'aNnota2H
I
'oid set8otaT2dou*le nue'aNnotaT3
C
notaTXnue'aNnotaTH
I
I
El m/todo promedio, dice ue de'ol'er el promedio, esto significa ue tendr como tipo
de'uelto un real del mismo tipo ue los atri*utos nota. 8ecesitamos adems una 'aria*le
donde guardar el clculo del promedio. 6.mo se calcula el promedio7 En este caso se
sumaran las tres notas y se di'idirn por tres 2el numero de notas3 y luego de*emos
de'ol'er el promedio.
dou*le promedio23
C
dou*le pH
pX2nota1Rnota2RnotaT3:TH
return2p3H
I
El m/todo situacin dice ue de'ol'er una letra 2c(ar3 dependiendo si el alumnos esta
apro*ado 2promedio^XT,WM3 o repro*ado.
c(ar situacion23
C
if2promedio23^XT.WM3
C
return2bAb3H
I
else
C
return2b=b3H
I
I
)i deseamos 'er esto funcionando de*emos crear nuestra aplicacin0
class AppAlumno
C
C
dou*le n1,n2,nT,pH
c(ar sitH
)ystem.out.println2FIngrese nota1F3H
n1XLeer.dato@ou*le23H
)ystem.out.println2FIngrese notaTF3H
nTXLeer.dato@ou*le23H
Alumno unoXne; Alumno2n1,n2,nT3H
pXuno.promedio23H
sitXuno.situacion23H
)ystem.out.println2FEl alumno esta0 FRsit3H
)ystem.out.println2Fcon nota0 FRp3H
I
I
4#
J el resultado ser0
A(ora me"oremos este mismo programa, pensando ue si el alumno esta repro*ado le
daremos otra oportunidad, para esto le cam*iaremos la peor nota por una nue'a la cual
en'iaremos por parmetro y de*eremos mostrar la nue'a situacin.
!ara resol'er esto, de*emos pensar ue solo sa*emos ue el alumnos esta repro*ado
cuando tenemos el o*"eto creado y el m/todo situacin nos entrega el resultado, entonces es
en este punto en donde de*emos preguntar si est o no repro*ado 2en la aplicacin3 y solo
si esta repro*ado solicitar una nue'a nota para en'iarla a la clase. !ero en la clase de*emos
tener otro m/todo ue cam*ie le peor nota por esta nue'a, el cual llamaremos
segundaLportunidad23, este m/todo no necesita de'ol'er nada solo cam*iar la peor nota
por la nue'a. 8uestra aplicacin entonces uedara0
class AppAlumno
C
C
dou*le n1,n2,nT,p,otraH
c(ar sitH
)ystem.out.println2FIngrese notaTF3H
nTXLeer.dato@ou*le23H
Alumno unoXne; Alumno2n1,n2,nT3H
pXuno.promedio23H
if2sitXXb=b3
C
)ystem.out.println2FIngrese nue'a notaF3H
otraXLeer.dato@ou*le23H
uno.segundaLportunidad23H
pXuno.promedio23H
I
I
I
A(ora en la clase plano de*emos agregar el m/todo segundaLportunidad23, pero notamos
ue adems necesitamos encontrar la peor nota y esta *-sueda podemos tam*i/n (acerla
con un m/todo el cual se llamara peor8ota23.
5/
6.mo construimos el m/todo peor8ota237 Este de*e de'ol'er la peor nota, ya ue la
necesitaremos en el m/todo segundaLportunidad, y de*emos comparar las tres notas
*uscando la peor. )i la nota1 es la peor de*e ser menor o igual a la nota2 y a su 'e% menor
o igual a la notaT y lo mismo de*e cumplirse para cada nota. Entonces tenemos0
dou*le peor8ota23
C
if2nota1]Xnota2__nota1]XnotaT3
C
return2nota13H
I
C
return2nota23H
I
if2notaT]Xnota1__notaT]Xnota23
C
return2notaT3H
I
I
)i de"amos el m/todo as, este no compila y el compilador indica ue falta un return. 6Ku/
est ocurriendo7 Lo ue pasa es ue el sistema dice0 en cada if tengo la opcin de entrar o
no 6Ku/ ocurre entonces si no entro en ning-n if7 6Ku/ de'uel'o en ese caso7 Ja ue
tengo ue de'ol'er algo siempre. !or lo tanto para solucionar esto podemos agregar un
return ue de'uel'a cualuier cosa, ya ue nosotros sa*emos ue el sistema siempre 'a a
entrar a un if, por lo tanto nunca llegara al -ltimo if 2el ue de'uel'e cualuier cosa3. L
*ien podemos declarar una 'aria*le ue sea la de'uelta y en cada if asignar a esta 'aria*le
lo ue de*era de'ol'er, 'eamos cmo ueda nuestro m/todo utili%ando esto -ltimo.
dou*le peor8ota23
C
dou*le pX0H
C
pXnota1H
I
C
pXnota2H
I
if2notaT]Xnota1__notaT]Xnota23
C
pXnotaTH
I
return2p3H
I
A(ora s, 'eamos cmo ueda el m/todo segundaLportunidad23. Este m/todo no necesita
de'ol'er nada 2'oid3 y lo ue de*e (acer es si la peor nota es la nota1 cam*iar esta por la
nota ue le llega por parmetro, si es la nota2 lo mismo y si es la tres igual.
'oid segundaLportunidad2dou*le otra3
C
if2peor8ota23XXnota13
C
set8ota12otra3H
I
if2peor8ota23XXnota23
5(
C
set8ota22otra3H
I
if2peor8ota23XXnotaT3
C
set8otaT2otra3H
I
I
6.mo aparecen los resultados a(ora7
.omo se (a podido 'er las sentencia if se pueden usar donde uno la necesite y cuantas
'eces estime con'eniente.
A(ora 'eamos un e"emplo donde usemos if y else.
.onstruir una clase llamada 8-meros ue tenga como atri*utos dos n-meros enteros y los
mayor230 m/todo ue de'uel'e el mayor de los dos n-meros.
par230 m/todo ue de'uel'e si el primer n-mero es par o impar.
di'isi*le2T230 m/todo ue de'uel'e si el segundo n-mero es di'isi*le por 2 y por T
simultneamente.
multiploMS230 m/todo ue de'uel'e si el segundo n-mero es m-ltiplo de M o S.
.onstruir una aplicacin ue permita crear un o*"eto y aplicar los todos los m/todos
construidos.
@esarrollo
8uestra clase tiene dos atri*utos enteros, como no se sa*e ue representan los declararemos
como int, sern pri'ados y por ende de*eremos construir un m/todo get y set para cada
atri*uto, adems del constructor por defecto o 'acio y el con parmetros. !or lo tanto,
nuestra clase uedara0
class 8umeros
C
pri'ate int num1,num2H

8umeros2int n1,int n23
C
num1Xn1H
num2Xn2H
I
52
8umeros23
C
I
int get8um123
C
return2num13H
I
int get8um223
C
return2num23H
I
'oid set8um12int nue'oNnum13
C
num1Xnue'oNnum1H
I
'oid set8um22int nue'oNnum23
C
num2Xnue'oNnum2H
I
I
Aeamos a(ora los m/todos customer0
El m/todo mayor de*e de'ol'er el mayor de los int por lo tanto su tipo de'uelto ser int.
=ecordar ue las posi*ilidades son0 ue el primer n-mero sea el mayor, ue el segundo
n-mero sea el mayor o ue sean iguales, por lo tanto se de*e definir ue de'ol'eremos
cuando sean iguales, podemos de'ol'er cualuiera de los n-meros o alg-n n-mero especial
ue nos indiue ue son iguales 2UUUUUU3. El m/todo uedara0
int mayor23
C
if2num1^num23
C
return2num13H
I
else
C
if2num2^num13
C
return2num23H
I
else
C
return2UUUUUUU3H
I
I
I
Es importante indicar ue en este caso no es necesario crear una 'aria*le para asignar y
luego de'ol'er como en el caso del e"ercicio anterior, ya ue 4a'a tiene claro ue con un if-
else se tienen completamente cu*iertas todas las posi*ilidades 2100\3. Analicemos a(ora
como construimos el m/todo par. En primer lugar de*emos aclarar cuando un numero es
par y lo es cuando al di'idirlo por 2 no nos so*ra nada, en otra pala*ras cuando el resto de
la di'isin por dos es igual a cero o *ien cuando el numero modulo 2 es igual a cero. !or
otra parte este m/todo de*e indicar si es par o impar 2no (ay ms posi*ilidades para un
entero3, entonces podramos de'ol'er una letra ue indiue ue es 2! o I3. El m/todo
uedara0
c(ar par23
5)
C
if2num1\2XX03
C
return2b!b3H
I
else
C
return2bIb3H
I
I
!or su parte en el m/todo di'isi*le2T23, tam*i/n es necesario aclarar 6u/ es di'isi*le7, se
dice ue un numero es di'isi*le por otro cuando al di'idir el primero por el segundo no
e>iste resto 2no so*ra nada3, por lo tanto, tam*i/n estamos (a*lando del modulo y podemos
afirmar ue un numero ser di'isi*le por otro si el modulo del primero por el segundo es
igual a cero. 8uestro m/todo de*e de'ol'er si es di'isi*le o no, por lo ue podemos
de'ol'er una letra 2) o 83 o *ien el *ooleano correspondiente 2true o false3. El m/todo
uedar0
*oolean di'isi*le2T23
C
if2num2\2XX0__num2\TXX03
C
return2true3H
I
else
C
return2false3H
I
I
#inalmente, analicemos el m/todo multiploMS23, 6u/ significado tiene la e>presin ser
m-ltiplo7, esta e>presin indica ue el numero en cuestin es di'isi*le por el otro n-mero.
En este caso estamos anali%ando si el numero2 es di'isi*le por M o S y de*eremos informar
el resultado el cual puede ser una letra o *ien una e>presin *ooleana 2true o false3. El
m/todo uedara0
*oolean multiploMS23
C
if2num2\MXX0``num2\SXX03
C
return2true3H
I
else
C
return2false3H
I
I
Ja tenemos lista la clase plano, a(ora de*emos construir la clase aplicacin. !ara ello
necesitamos algunas 'aria*les, dos enteros para los n-meros ue solicitaremos, una
'aria*le para reci*ir el resultado del mayor 2tam*i/n entera3, una 'aria*le carcter para
reci*ir el resultado de par y dos 'aria*les *ooleanas para reci*ir el resultado de di'isi*le2T
y multiploMS. Luego de*emos pedir al usuario los datos ue necesitamos para crear el
o*"eto y una 'e% ue los (emos ingresados podemos crear dic(o o*"eto y finalmente
54
mostrar los datos. !ero au de*emos recordar ue de'uel'en los m/todos para 'er la forma
en ue mostraremos los resultados.
!ara el m/todo mayor el sistema nos de'ol'er el numero mayor cuando son distintos pero
el numero UUUUUUU cuando sean iguales por lo tanto de*emos preguntar si lo ue de'uel'e
el m/todo es este n-mero y si es as mostraremos ue los n-meros son iguales sino
mostraremos el numero mayor.
En el caso del m/todo par, el programa nos de'uel'e una letra la cual de*emos comparar y
si es igual a Y!Z mostrar en pala*ras el resultado o*tenido, sino mostrar en pala*ras el otro
resultado o*tenido.
En los dos m/todos finales el resultado es un *ooleano y de*emos preguntar si lo ue
de'uel'e es 'erdadero y si lo es mostrar una frase adecuada sino otra frase. El programa se
'er0
class App8umeros
C
C
int n1,n2,mayH
c(ar parH
*oolean di',mulH
)ystem.out.println2FIngrese un enteroF3H
n1XLeer.datoInt23H
)ystem.out.println2FIngrese otro enteroF3H
n2XLeer.datoInt23H
8umeros unoXne; 8umeros2n1,n23H
mayXuno.mayor23H
if2mayXXUUUUUUU3
C
)ystem.out.println2FLos numeros son igualesF3H
I
else
C
)ystem.out.println2FEl numero mayor es0 FRmay3H
I
parXuno.par23H
if2parXXb!b3
C
)ystem.out.println2FEl primer numero es parF3H
I
else
C
)ystem.out.println2FEl primer numero es impar F3H
I
di'Xuno.di'isi*le2T23H
if2di'XXtrue3
C
)ystem.out.println2FEl segundo numero es di'isi*le por 2 y TF3H
I
else
C
)ystem.out.println2FEl segundo numero no es di'isi*le por 2 y TF3H
I
mulXuno.multiploMS23H
if2mulXXtrue3
C
)ystem.out.println2FEl segundo numero es multiplo de M o SF3H
55
I
else
C
)ystem.out.println2FEl segundo numero no es multiplo de M o SF3H
I
I
I
'entencia s(itc&
E>iste otra sentencia condicional pero es parte de lo mismo y solo se puede usar en algunos
casos. Esta sentencia se llama +s;itc(, y corresponde a una especie de 'arios if seguidos
pero la 'aria*le ue se compara de*e ser entera o carcter y la comparacin solo de*e ser
de igualdad y esta comparacin se reali%a con la pala*ra +case, ad"untando al lado el 'alor
usado para comparacin y terminando con dos puntos, adems esta sentencia no separa
cada comparacin con lla'es ue maruen el *loue, sino ue cuando termina, separa con
la pala*ra reser'ada +*rea?,, ue significa ue rompe el proceso de comparacin y se sale
de la sentencia s;itc(. )i el *rea? es omitido el proceso continua en la siguiente
comparacin y asi sucesi'amente (asta encontrar un *rea? o el final del *loue s;itc(.
Adems esta sentencia en forma opcional la podemos terminar con un +default, ue es una
especie de else pero glo*al de todos los case comparados del s;itc( y donde solo ingresara
si no entro en ning-n case. !ara entender me"or como tra*a"a esta sentencia 'eamos un
e"emplo0 pesemos en un negocio ue 'ende cigarrillos y el dueOo necesita un sistema ue
mediante el ingreso de un cdigo de'uel'a el precio del cigarro. )e tiene la siguiente ta*la0
cdigo 9arca precio
1 cent 1U00
2 Luc?y 1M00
T <elmont 1200
V 9arl*oro 1M00
M Ad'ance 1100
U Bilton 1M00
El m/todo de'ol'er el precio y utili%ara el cdigo para *uscarlo el cual de*er llegar como
parmetro o *ien ser un atri*uto, entonces0
int precio23
C
int pH
s;itc(2codigo3
C
case 10
pX1U00H
*rea?H
case 20
pX1M00H
*rea?H
case T0
pX1200H
*rea?H
5!
case V0
pX1M00H
*rea?H
case M0
pX1100H
*rea?H
case U0
pX1M00H
*rea?H
default0
pX0H
I
return2p3H
I
!odemos 'er ue (ay precios ue se repiten, por lo tanto podemos me"orar nuestro m/todo
de la siguiente manera0
int precio23
C
int pH
s;itc(2codigo3
C
case 10
pX1U00H
*rea?H
case 20
case V0
case U0
pX1M00H
*rea?H
case T0
pX1200H
*rea?H
case M0
pX1100H
*rea?H
default0
pX0H
I
return2p3H
I
Aemos ue en el case 2,V y U el resultado es el mismo, por esto se pueden colocar "untos y
cualuier 'alor 2de estos tres3 ue se ingrese, el resultado o*tenido es el mismo. .on esto
podemos 'er ue los 'alores no necesariamente de*en ir en orden y solo de*e de"arse al
final si es ue se uiere incorporar el default. Esta sentencia es muy utili%ada para la
construccin de men-s en la clase aplicacin.
E"ercicios propuestos
E&ercicio 1
)e desea resol'er de forma general, la siguiente ecuacin de segundo grado a1
2
R b1 R c X 0
donde0
- a, b y c0 son n-meros reales cualesuiera correspondientes a los coeficientes de la ecuacin. Bay ue
tener cuidado de ue a y * no pueden ser ceros
- 10 Incgnita
Bay ue tener en cuenta0
<
*
Cuadrante
2
Cuadrante
(
Cuadrante
)
Cuadrante
4
56
- )i a es cero, pero * es distinto de ceroH la solucin se remite a una ecuacin lineal ue sera0
1 X -c:*
- )i a es distinto de cero, se puede aplicar la formula cuadrtica ue es0
@onde el discriminante 2*
2
d Vac3 indica0
o )i es cero, la solucin es -nica y es un n-mero real
o )i es positi'o tiene dos soluciones y son n-mero reales
o )i es negati'o tiene dos soluciones y son n-meros comple"os
1. =eali%ar una clase llamada .uadratica0
a3 @efina 1d. los atri*utos ue tendr la clase
*3 =eali%ar los siguientes m/todos0
a. tipos@e.oeficientes0 de'ol'er0
0 si los coeficientes a y * son ceros
-1 si slo el coeficiente a es cero
1 si am*os coeficientes 2a y *3 son distintos de cero
*. discriminante0 de'ol'er el 'alor del discriminanteH esto es0
0 si el discriminante es cero
-1 si el discriminante es negati'o
1 si el discriminante es positi'o
c. solucin0 mostrar la solucin de la ecuacin
d. construir un m/todo mutador para cada atri*uto, ue incremente en 1 +a,, ue disminuya en
2 a +*, y aumente un M\ a +c,.
2. =eali%ar una aplicacin ue permita crear un o*"eto de tipo .uadrtica y luego mostrar0
La ecuacin eee si tiene o no tiene.
)i tiene solucin real, mostrarla.
)ino preguntar si desea modificar los atri*utos si la respuesta es afirmati'a, aplicar los m/todos
mutadores so*re el o*"eto y 'ol'er a re'isar la ecuacin.
E&ercicio 2
1. =eali%ar una clase llamada !unto, la cual permitir mane"ar puntos con coordenadas enteras 2>,y3.
Los m/todos ue de*er tener la clase son los siguientes0
a. cuadrante230 @e'ol'er el n-mero del cuadrante donde se encuentra el punto. )i alguna
coordenada fuese cero de'ol'er 0.
@onde0

)i el punto fuese 2-T.-M3, de'ol'er T
*. mayor230 @e'ol'er la coordenada mayor entre > e y
5-
c.
2. =eali%ar una aplicacin con la clase !unto ue permita0
a. Ingresar dos puntos cualuiera
*. 9ostrar los puntos
c. 9ostrar por pantalla en ue cuadrante se encuentran los puntos
d. 9ostrar por pantalla la coordenada mayor de los puntos
E&ercicio
=eali%ar una clase llamada &ermometro la cual tendr0
- .omo atri*utos0
- temperatura, ue es un n-mero real y representa la temperatura del momento
- minima, ue es un n-mero real y representa la mnima temperatura ue podra (a*er
- ma1ima, ue es un n-mero real y representa la m>ima temperatura ue podra (a*er
- J los siguientes m/todos0
- sube2emperatura3 Aumentar la temperatura en incremento, 'alidar ue no so*repase el lmite, si
as fuese la temperatura de*er uedar con el 'alor ma1imo
- baja2emperatura3 @isminuye la temperatura en incremento, 'alidar ue no so*repase el lmite, si as
fuese la temperatura de*er uedar con el 'alor minimo
2.- =eali%ar una aplicacin ue permita0
- .rear 2 o*"etos de tipo &ermometro
- Ingresar los datos a cada o*"eto
- 9ostrar las temperaturas de cada o*"eto
- Ingresar una cantidad de grados y0
o )u*ir la temperatura en la cantidad ingresada al primer o*"eto.
o <a"ar la temperatura en la cantidad ingresada al segundo o*"eto
- 9ostrar las temperaturas de cada o*"eto
E&ercicio '
1. .rear una clase llamada &riangulo la cual tendr como atri*utos sus tres lados 2a, b, y c3 reales y los
siguientes m/todos0
a. permetro230 retornar el permetro del triangulo
*. es&riangulo230 de'ol'er true si las medidas corresponden a un triangulo, false en caso contrario.
Las medidas corresponden a un triangulo si la suma de dos de sus lados es mayor al tercero, para
todos sus lados. E"emplo las siguientes medidas no corresponden a un triangulo 10 20 10
c. tipo&riangulo0 @e'ol'er el tipo de triangulo, esto es0 1 si es euiltero, 2 si es escaleno y T si es
issceles
d. areaEspecial230 retornar el rea del tringulo seg-n la e>presin siguiente, en la ue p es la
mitad del permetro0
2. =eali%ar una aplicacin ue permita crear 2 o*"etos de tipo &riangulo con 'alores ingresados por el
usuario y luego mostrar0
a. !ermetro de cada triangulo, siempre y cuando sean triangulo
*. area de cada triangulo, siempre y cuando sean triangulo
c. El tipo de cada triangulo
E&ercicio "
1. =eali%ar una clase llamada #ec(a la cual tendr como atri*utos0 dia, mes y aOo y los siguientes
m/todos0
a. es<isiesto0 @e'ol'er true si el aOo es *isiesto, false en caso contrario.
*. cantidad@ias9es0 @e'ol'er la cantidad de das ue tiene el mes. !or E"emplo0
5#
si mes fuese T de'ol'er T1
si mes fuese 2 de'ol'er 2W siempre y cuando el aOo se *isiesto
c. mesIn'alido0 )i el mes es in'lido, asignar a mes el 'alor de 1. 1n mes es in'alido si no se
encuentra en el rango 1 a 12
d. diaIn'alido0 )i el da es in'lido, asignar a da el 'alor de 1. 1n da es in'alido si es menor
o igual a cero y se so*repasa a la cantidad de das ue tiene el mes
e. aOoIn'alido0 )i el aOo es in'lido, asignar a aOo el 'alor de 200M. un aOo es in'alido si no
se encuentra en el rango 1W00 a 20M0
2. =eali%ar una aplicacin ue permita0
a. .rear dos o*"etos de tipo #ec(a
*. Ingresar los datos a cada o*"eto
c. 9ostrar por pantalla0
Las #ec(as ingresados son0
dia mes aOo
--- --- ---
--- --- ---
d. Llamar a los m/todos mesIn'alido, diaIn'alido, aOoIn'alido para cada o*"eto
e. 9ostrar por pantalla0
Las #ec(as 'alidas son0
dia mes aOo
--- --- ---
--- --- ---
f. 9ostrar por pantalla la cantidad de das ue tiene la segunda #ec(a
E&ercicio )
=eali%ar una clase llamada &ren, ue tendr por atri*utos0
Aalor del cm., tipo de pasa"e 2E"ecuti'o X1, 8ormal X2 y Econmico XT3, temporada 2alta X1, *a"a
X23 y distancia 2cm.3.
.ree un constructor adecuado y los siguientes m/todos0
1. distanciaIn'alida230 de'ol'er false si la distancia es menor ue 20 cm. o mayor a 1000 cm., true en
caso contrario.
2. de'uel'eAalor!asa"e8eto230 si la distancia es 'alida, de'ol'er el 'alor del pasa"e sa*iendo ue este
se o*tiene del producto de la distancia de destino por el 'alor del ?m.
T. ra*a4a'alor!asa"e&ipo23, re*a"ar el 'alor del pasa"e considerando el tipo, sa*iendo ue so*re el
'alor del cm. se (acen los siguientes descuentos0
a. )i el tipo es E"ecuti'o se mantiene el 'alor.
*. )i el tipo es 8ormal se re*a"a el 'alor en un 1S\.
c. )i el tipo es Econmico se re*a"a en un TT \.
V. re*a4a'alor!asa"e&emporada23, re*a"ar el 'alor del pasa"e considerando la temporada, sa*iendo ue
si es temporada alta se mantiene el 'alor y si es temporada *a"a, se reali%a un descuento del 2M\ del
'alor del cm.
M. de'uel'e&otal!agar2numero pasa"es30 de'ol'er el total neto a pagar, para un cierto numero de
pasa"es comprados 2'alor ue se de*e llegar por parmetro3 y se calculara multiplicando el 'alor neto
del pasa"e por el numero de pasa"es solicitados.
!/
=ealice una aplicacin ue permita crea tres o*"etos del tipo &ren donde cada o*"eto compra 'arios pasa"es,
uno de ellos de*e compra en Econmica y temporada *a"a, otro en 8ormal y temporada alta y el ultimo en
E"ecuti'a y temporada *a"a. @etermine el 'alor a pagar por cada pasa"ero y indiue cuantos pasa"es se
'endieron y cuanto dinero de*era tener en ca"a.
E&ercicio *
1. =eali%ar una clase llamada +ehiculo la cual tendr como atri*utos enteros numeroAe(iculo,
'elocidad2cm:Bora3, rendimiento 2cm:litros3 y capacidadEstanue y los siguientes m/todos0
,elocidadPermitida0 @e'ol'er true si el 'e(culo 'a con una 'elocidad permitida en ciudad 2ma>
U0c93H en caso contrario, de'ol'er false.
!or e"emplo0 )i el 'e(culo tiene una 'elocidad de SM 2cm:Bora3 el m/todo de'ol'er false
llega-Destino0 @e'ol'er true si para una distancia d y partiendo con el estanue lleno, llega con
/>itoH en caso contrario, de'ol'er false.
!or e"emplo0 )i el 'e(culo tiene una 'elocidad de S0 2cm:Bora3, el rendimiento es de 1M
2cm:litros3 y la capacidadEstanue es de V0 litros y la distancia a recorrer es de UV0 c9 entonces el
m/todo de'ol'er false, pues el auto andar con el estanue lleno U00 c9 2V0[1M3
llenaEstan.ue0 de'ol'er la cantidad de 'eces ue se necesita llenar el estanue para recorrer una
distancia d
!or e"emplo0 )i el 'e(culo tiene una 'elocidad de S0 2cm:Bora3, el rendimiento es de 1M
2cm:litros3 y la capacidadEstanue es de V0 litros y la distancia a recorrer es de 1TV0 c9 entonces
el m/todo de'ol'er 2, pues el auto andar con el estanue lleno U00 c9 con un solo estanue y lo
ue se desea recorrer es 1TV0c9
1TV00U00X2
1V0
8ecesitara 2 estanue, pero el resto de la di'isin no es cero, por lo tanto, necesitar T
gasto+ia&e0 @e'ol'er la cantidad de litros de *encina ue gast el 'e(culo en una distancia d
2. =eali%ar una aplicacin ue permita crear dos o*"etos de tipo +ehiculo, ingresar los datos a cada o*"eto y
luego0
a. 9ostrar los datos de cada o*"eto de la siguiente forma0
Ae(iculo 8f 'elocidad rendimiento capacidadEstanue
--- --- --- ----
--- --- --- ----
*. !edir La distancia a recorrer para cada 'e(culo
c. 9ostrar los datos de cada o*"eto de la siguiente forma0
Ae(iculo 8f Aelocidad @istancia Aeloc. permitida Llega a destino .ant. Estanues Llenados
--- --- --- --- ----- ----
--- --- --- --- ----- ----
E"emplo0
)upongamos ue el primer 'e(culo posee los siguientes datos0
Ae(iculo 8f 12T, 'elocidadX MM, rendimientoX20, y capacidadEstanueXVM
J ue la distancia ue desea recorrer es de MT0
!or lo tanto de*er mostrar0
!(
Ae(iculo 8f Aelocidad @istancia Aeloc. permitida Llega a destino .ant. Estanues Llenados
12T MM MT0 )I )I 1
8otase ue de*e mostrar )I en 'e% de &=1E
E&ercicio /
1. La profesora de la asignatura Introduccin a la programacin guarda la siguiente informacin de sus
alumnos0 codigoAlumno, nota)olemne1, nota)olemne2, nota.ontrol1, nota.ontrol2 nota.ontrolT,
nota.ontrolV y nota.ontrolM. =eali%ar una clase la cual refle"e lo anterior y adems tenga los siguientes
m/todos0
a3 modifica.ontroles0 Asignar a las dos notas ms *a"as de los controles, las notas ue o*tu'o en los
controles recuperati'os.
*3 nota!resentacion0 de'ol'er la nota de presentacin a e>amen, sa*iendo ue las solemnes eui'alen
un TM\ y el promedio de los controles un T0\
c3 nota#inal0 de'ol'er la nota final del alumno, sa*iendo ue la nota de presentacin a e>amen
eui'ale un U0\ y la nota de e>amen un V0\
d3 situacion0 de'ol'er true si el alumno apro* la asignatura, false en caso contrario
e3 tipoAlumno0 de'ol'er el tipo de alumno seg-n la siguiente escala0
8ota#inal &ipo alumno
S.0-U.0 A
M.W-M.0 <
V.W-V.0 .
T.W-T.0 @
2.W-2.0 E
1.W-1.0 #
f3 otraLportunidad0 de'ol'er true si el alumno tiene otra oportunidad para rendir una prue*a, false en
caso contrario. La oportunidad la o*tendr si el alumno es de tipo @.
a3 .rear T o*"etos de tipo Asignatura
*3 Ingresar los datos a cada o*"eto
c3 9ostrar por pantalla los datos de los o*"etos de la siguiente forma0
.odigo Alumno )1 )2 .1 .2 .T .V .M
------------- -- -- -- -- -- -- --
------------- -- -- -- -- -- -- --
------------- -- -- -- -- -- -- --
d3 !ara todos los o*"etos, ingrese las dos notas recuperati'as de control y modifiue las notas de
controles.
e3 9ostrar por pantalla0
.odigo Alumno .1 .2 .T .V .M
------------- -- -- -- -- --
------------- -- -- -- -- --
------------- -- -- -- -- --
Ingrese las notas ue o*tu'ieron en el e>amen los tres alumnos y luego0
f3 9ostrar por pantalla0
.odigo Alumno 8ota!res. 8ota E>amen 8ota #inal &ipo Alumno
------------- ---- ---- ---- --
------------- ---- ---- ---- --
------------- ---- ---- ---- --
g3 9uestre por pantalla el cdigo del o los alumnos ue tiene otra oportunidad. En caso ue no (ayan
alumnos, 9ostrar mensa"e adecuado.
E&ercicio 0
!2
1. =eali%ar una clase llamada &ienda la cual tendr los siguientes atri*utos0 codigoArticulo,
cantidadArticulos y precio<rutoArtculo. J los siguientes m/todos0
a. precioAenta0 @e'ol'er el precio de 'enta ue tendr el artculo. )e sa*e ue el dueOo
incrementa el precio *ruto en un TT\
*. cantidad8ecesaria0 de'ol'er true si la cantidadArticulos es mayor a la cantidad ue se desea
'ender, false en caso contrario
c. 'enta0 descontar a la cantidadArticulos la cantidad ue se desea 'ender, siempre y cuando (aya
cantidad8ecesaria, Adems de'ol'er el total ue de*er pagar el comprador
a. .rear dos o*"etos de tipo tienda
*. Ingresar los datos a cada o*"eto
c. 9ostrar por pantalla0
.odigo Art .antidad Art !recio Aenta
------------- --------------- ---------------
------------- --------------- ---------------
d. Aender una cantidad de artculos del o*"eto2, mostrando la cantidad a pagar por el comprador.
)i no se pudo reali%ar la 'enta, mostrar mensa"e necesario.
e. Aender una cantidad de artculos del o*"eto1, mostrando la cantidad a pagar por el comprador.
)i no se pudo reali%ar la 'enta, mostrar mensa"e necesario.
f. 9ostrar por pantalla0
.odigo Art .antidad Art !recio Aenta
------------- --------------- ---------------
------------- --------------- ---------------
'entencias de control iterativas
.uando la informacin ingresa en un *loue de control condicional 2if, else o s;itc(3, lo
(ace una sola 'e%, reali%ando las instrucciones escritas y saliendo del *loue. !ero e>isten
situaciones donde se desea ue mientras la condicin de ingreso se cumpla la informacin
permane%ca en el *loue, reali%ando las tareas descritas. .omo en el caso de un relo",
donde mientras tenga cuerda o *atera seguir a'an%ando y entregando la (ora actual. En
estas situaciones estamos frente a una sentencia de control pero iterati'a 2repetiti'a3. En
4a'a encontramos tres sentencias iterati'as ;(ile, do-;(ile y for, las tres reali%an lo mismo,
ciclos reiterati'os mientras la condicin se cumpla, lo ue cam*ia es la forma de ingreso al
ciclo o su estructura.
'entencia de control iterativa (&ile )mientras*
La primera sentencia iterati'a ue anali%aremos es el ;(ile 2mientras3 y corresponde a un
*loue de programa ue presenta una condicin de ingreso 2*ooleana3, si esta se cumple se
ingresa al *loue y se seguir repitiendo mientras la condicin se siga cumpliendo. El
formato de la sentencia es0
;(ile2condicin3
!)
C
Instrucciones
I
Es importante indicar ue la condicin para poder ingresar al ;(ile de*e cumplirse
pre'iamente, y en su interior se reali%aran todos los pasos descritos en las instrucciones,
(asta encontrase con la lla'e ue cierra el *loue, en ese momento, se 'uel'e al principio
del ;(ile y nue'amente anali%a la condicin, y si esta se sigue cumpliendo, 'uel'e a
reali%ar todo el proceso (asta ue la condicin no se cumpla, y en ese caso se saltara el
*loue ;(ile, y continuara con la primera instruccin a continuacin del *loue ;(ile. )i la
condicin inicial del ;(ile no se cumple la primera 'e%, no se ingresa en /l y se lo salta
para continuar en la primera instruccin inmediatamente posterior al *loue del ;(ile.
Aeamos cmo se puede utili%ar esta sentencia, para ello construiremos una clase aplicacin
y colouemos en mensa"e dentro de un *loue ;(ile y o*ser'emos ue ocurre0
class AppE"emplo
C
C
int condX10H

;(ile2condXX103
C
)ystem.out.println2FBolaF3H
I
I
I
6Ku/ (a pasado7 1n ciclo eterno de muc(os +Bola, aparece en pantalla. 6!or u/7 El ciclo
;(ile se repite siempre porue la condicin se cumple siempre por lo ue imprime siempre,
(asta ue se corte la lu% o se llene la memoria ram. Esto significa ue nuestro ciclo ;(ile
de*e tener incorporado alg-n incrementador o condicin de finali%ado para ue nos sea -til
y pueda terminar en alg-n momento. Aeamos a(ora0
class AppE"emplo
C
C
int condX1H

;(ile2cond]103
C
)ystem.out.println2FBolaF3H
condXcondR1H
I
I
I
El resultado nos muestra nue'e 'eces el +Bola, y se de*e a ue (emos esta*lecido una
'aria*le de inicio ue adems cumple con la condicin ue permitir el ingreso al ;(ile y
adems se (a agregado un incrementador para la 'aria*le cond para (acer finito al ciclo.
Esta sentencia es muy 'erstil y se puede usar donde se necesite, ya sea en una clase plano
o aplicacin, tam*i/n se puede colocar un ;(ile dentro de otro ;(ile y dentro de este otro
!4
;(ile y as sucesi'amente tantas 'eces como se necesite. @entro de un ;(ile tam*i/n
pueden ir sentencias if, else o s;itc( o dentro de ellas incorporar uno o mas ;(ile. 8o
e>isten lmites para su utili%acin.
=ealicemos un e"emplo para 'er la 'ersatilidad ue presenta esta sentencia de control.
.onstruir una clase llamada ciclo ue tiene como atri*uto un entero de 'arios dgitos y los
m/todos set, get, constructores y los siguientes customer0
cuenta@igitos230 m/todo ue de'ol'er cuantos dgitos tiene el entero.
cuenta!ares230 m/todo ue de'ol'er cuantos pares tiene el entero.
suma@igitosImpares230 m/todo ue de'ol'er la suma de los dgitos impares.
digito9ayor230 m/todo ue de'ol'er el digito mayor del entero.
Adems, construir una aplicacin ue permita 'er operar a estos m/todos, pero la
aplicacin de*e tener un men- donde se de*e seleccionar la ue se desea 'er y salir
mediante una opcin.
@esarrollo
El atri*uto es un entero de 'arios dgitos, pensemos ue es del tipo int esto significa ue
puede tener sin pro*lemas (asta W dgitos. Entonces sus m/todos get, set y constructores
uedaran0
class .iclo
C
pri'ate int enteroH

.iclo2int en3
C
enteroXenH
I
.iclo23
C
I
int getEntero23
C
return2entero3H
I
'oid setEntero2int nue'oNentero3
C
enteroXnue'oNenteroH
I
I
J los m/todos customer sern0
El m/todo cuenta@igitos23, de*e de'ol'er la cantidad de dgitos por lo ue tam*i/n puede
ser int. 6.mo contamos los dgitos de un numero7 La forma es simple, recordemos ue
cada 'e% ue multiplicamos un numero entero por 10 este crece en un digito por lo tanto
cada 'e% ue lo di'idimos por 10 le uitamos un digito, entonces di'idiremos el numero
por 10 sucesi'as 'eces (asta ue no me uede numero 2cero3, e'identemente de*emos
contar cuantas 'eces es necesario di'idir por 10 y sacar una copia del atri*uto la cual
usaremos para tra*a"ar ya ue si no (acemos esto el atri*uto uedara en cero. !asemos
estos a cdigo0
!5
int cuenta@igitos23
C
int cantidadX0,copiaXenteroH
;(ile2copia^03
C
copiaXcopia:10H ::di%ido por $# y guardo el resultado en la misma %ariable
cantidadXcantidadR1H ::cuento la %uelta
I
return2cantidad3H
I
El m/todo cuenta!ares23 de*e de'ol'er la cantidad de pares, por lo tanto su tipo de'uelto es
int. En esta ocasin necesito en primer lugar capturar cada digito y luego determinar si es
par y si lo es contarlo. !ara captura el digito de*o recordar una propiedad matemtica ya
'ista +el modulo,, si tomo cualuier entero y le (ago modulo 10 o*tengo como resultado el
ultimo digito y para 'erificar si es par pregunto si el modulo 2 de este digito es igual a cero.
1na 'e% reali%ado esto descartamos el -ltimo digito del n-mero di'idiendo por 10. )e
repite el proceso (asta ue se nos aca*e el numero 2llegue a cero3.
int cuenta!ares23
C
int cantidadX0,dig,copiaXenteroH
;(ile2copia^03
C
digXcopia\10H//capturamos el ultimo digito
if2dig\2XX03//preguntamos si el digito es par
C
cantidadXcantidadR1H//contamos los digitos pares
I
copiaXcopia:10H//eliminamos el ultimo digito
I
return2cantidad3H
I
El siguiente m/todo, suma@igitosImpares23, es muy parecido al anterior, pero a(ora en 'e%
de contar de*emos sumar. !or lo tanto, declaramos un acumulador 2iniciali%ado en cero,
para ue no tenga nada al principio3, un dig para guardar el digito capturado con el modulo
y (acemos una copia del atri*uto 2para no modificarlo3.
int suma@igitosImpares23
C
int sumaX0,dig,copiaXenteroH
;(ile2copia^03
C
if2dig\2GX03//preguntamos si el digito es impar
C
sumaXsumaRdigH//sumamos los digitos impares
I
copiaXcopia:10H//eliminamos el ultimo digito
I
return2suma3H
I
#inalmente el -ltimo m/todo, digito9ayor23 de'ol'er el digito mayor, por lo cual su tipo
de'uelto es int. !ara su *-sueda de*eremos capturar cada digito del n-mero y compararlo
con el mayor guardado y si este es mayor guardar este nue'o, luego eliminar el digito
re'isado y repetir el proceso (asta ue no me ueden dgitos. !ara esto de*emos declarar
!!
una 'aria*le para ir guardando el digito mayor, para comen%ar de*emos asignarle un 'alor
ue estemos seguros ue en la primera comparacin ser reempla%ado y este es el menor
'alor posi*le, por e"emplo en este caso -1.
int digito9ayor23
C
int mayorX-1,dig,copiaXenteroH
;(ile2copia^03
C
if2dig^mayor3//preguntamos si este digito es mayor que el %alor contenido en mayor
C
mayorXdigH//si es mayor, dejamos en la %ariable mayor el %alor del digito
I
copiaXcopia:10H//eliminamos el digito anali,ado
I
return2mayor3H//de%ol%emos el digito mayor encontrado
I
A(ora analicemos la construccin de la aplicacin, en ella de*emos declarar una 'aria*le
entera para guardar el numero de 'arios dgitos ue ingresara el usuario y una para cada
m/todo ue llamemos, adems de una para la opcin ue el usuario digitara para 'er los
resultados y para salir.
class App.iclo
C
C
int entero,digitos,pares,suma,mayor,opcionH
)ystem.out.println2FIngrese un entero de 'arios digitosF3H//solicitamos el ingreso del entero de %arios digitos
enteroXLeer.datoInt23H//capturamos el %alor ingresado
.iclo unoXne; .iclo2entero3H//creamos el objeto
opcionX0H//asignamos un %alor a opci0n para que pueda entrar al ciclo por primera %e,
;(ile2opcionGXM3//declaramos el ciclo para que gire mientras opci0n sea distinta de ! ya que con ese %alor sale
C
)ystem.out.println2FKue desea (acer7 digite opcionF3H
)ystem.out.println2F10 Aer cuantos digitos tiene el numeroF3H
)ystem.out.println2F20 Aer cuantos pares tiene el numeroF3H
)ystem.out.println2FT0 Aer la suma de los digitos del numeroF3H
)ystem.out.println2FV0 Aer digito mayorF3H
)ystem.out.println2FM0 )alirF3H
opcionXLeer.datoInt23H//leemos la opci0n digitada por el usuario
s;itc(2opcion3//ingresamos al s4itch con la opci0n digitada por el usuario
C
case 10
digitosXuno.cuenta@igitos23H
)ystem.out.println2FLa cantidad de digitos es0 FRdigitos3H
*rea?H
case 20
paresXuno.cuenta!ares23H
)ystem.out.println2FLa cantidad de pares es0 FRpares3H
*rea?H
case T0
sumaXuno.suma@igitosImpares23H
)ystem.out.println2FLa suma de digitos imapres es0 FRsuma3H
*rea?H
case V0
mayorXuno.digito9ayor23H
)ystem.out.println2FEl digito mayor es0 FRmayor3H
*rea?H
case M0//case ! para poder salir cuando el usuario quiera
!6
*rea?H
default0 //esta instrucci0n es por si el usuario ingresa un %alor diferente a $,',,& o !
)ystem.out.println2F)olo entre 1 y MF3H
I
I//cerramos el 4hile para %ol%er al men5 o salir
I
I
La salida de nuestro programa a(ora parece un programa de 'erdad0
.omo (emos 'isto el ciclo ;(ile se puede utili%ar para la construccin de m/todos o para la
aplicacin en otras pala*ras donde estimemos con'eniente.
@esarrollemos otro e"emplo0 construir una clase llamada .iclo2, donde se tiene como
atri*uto un entero de 'arios dgitos y los m/todos get, set, constructores y los siguientes
customer0
in'ierte8umero230 este m/todo de'ol'er el mismo n-mero pero con sus dgitos
in'ertidos 2si era 12T de'ol'er T213.
cam*ia@igitos!aresS230 este m/todo de'ol'er el mismo n-mero pero con sus
dgitos pares cam*iados por S 2si era 12TV de'ol'er 1STS3.
primo230 este m/todo de'ol'er si el numero es primo.
.onstruir adems una aplicacin con men- donde el usuario salga solo cuando lo desee.
@esarrollo
La primera parte de la clase plano es similar a la anterior ya ue solo cam*ian los m/todos
de la clase0
class .iclo2
C
pri'ate int enteroH

.iclo22int en3
C
enteroXenH
I
.iclo223
C
I
int getEntero23
!-
C
return2entero3H
I
'oid setEntero2int nue'oNentero3
C
enteroXnue'oNenteroH
I
I
6.mo construimos el m/todo in'ierte8umero237 Ja (emos 'isto ue podemos desarmar
un numero di'idi/ndolo sucesi'as 'eces por 10, pero ue pasa si antes de di'idir por 10
capturamos el digito 2modulo3 y lo multiplicamos por 10, *otamos el digito di'idiendo por
10 y repetimos el proceso pero a(ora sumamos el digito capturado al producto anterior y lo
multiplicamos por 10 y seguimos (asta terminar con el n-mero inicial 2cuando lleguemos a
cero3. En n-meros es 2pensemos ue el n-mero inicial es 12TV30
12TV\10XV V>10
12TV:10 V0
12T\10XT V0RTXVT
12T:10 VT>10XVT0
12\10X2 VT0R2XVT2
12:10 VT2>10XVT20
1\10X1 VT20R1XVT21
1:10
0
Lo ue estamos 'iendo es el proceso cclico ue demos programar, el m/todo de'ol'er un
entero, necesitamos un nue'o n-mero ue de*er partir en cero y guardara el numero ue
se 'a formando, necesitamos tam*i/n donde de"ar el digito ue estamos capturando y
finalmente necesitamos una copia de nuestro atri*uto.
int in'ierte8umero23
C
int nue'oX0,dig,copiaXenteroH
;(ile2copia^03
C
digXcopia\10H//capturamos el ultimo digito del numero
nue'oXnue'o[10RdigH//multiplicamos por $# el acumulado y le sumamos el digito capturado
copiaXcopia:10H//botamos el digito capturado
I
return2nue'o3H//de%ol%emos el numero in%ertido
I
Aeamos el siguiente m/todo, cam*ia@igitos!aresS23, au la diferencia est en ue
de*emos preguntar si el digito capturado es par antes de incorporarlo al nue'o n-mero y si
lo es cam*iarlo por S sino de*emos de"arlo igual. !ero de*emos recordar ue el numero
resultante estar in'ertido por lo tanto de*emos darlo 'uelta para poder de'ol'er el numero
ue se nos pide.
int cam*ia@igitos!aresS23
C
int nue'oX0,dig,copiaXentero,finX0H
;(ile2copia^03
C
digXcopia\10H//sacamos el ultimo digito
!#
if2dig\2XX03//preguntamos si este digito es par
C
nue'oXnue'o[10RSHsi lo es lo reempla,amos por 6
I
else
C
nue'oXnue'o[10RdigH//sino lo es dejamos el digito
I
copiaXcopia:10H//botamos el digito re%isado
I
;(ile2nue'o^03//damos %uelta el numero
C
digXnue'o\10H
finXfin[10RdigH
nue'oXnue'o:10H
I
return2fin3H//de%ol%emos el numero como se nos pide
I
#inalmente el m/todo primo23, lo primero en aclarar es 6.undo un numero es primo7 1n
numero es primo cuando es di'isi*le solo por 1 y por si mismo. Es muy importante /l solo,
ya ue todos los n-meros son di'isi*les por 1 y por s mismo y no todos son primos. !or lo
tanto lo ue de*emos (acer es tomar el n-mero y contar cuantas 'eces es di'isi*le por cada
uno de los n-meros ue lo componen por e"emplo si nuestro n-mero es U0
U es di'isi*le por 1 si
U es di'isi*le por 2 si
U es di'isi*le por T si
U es di'isi*le por V no
U es di'isi*le por M no
U es di'isi*le por U si
A(ora contamos los s, ue son V. !or lo tanto U no es primo ya ue para serlo el contador
de*era arro"ar solo 2.
!or otra parte el m/todo de*e de'ol'er si es o no primo, por lo cual podra de'ol'er un
*ooleano.
*oolean primo23
C
int contadorX0,'arX1H
;(ile2'ar]Xentero3
C
if2entero\'arXX03
C
contadorXcontadorR1H
I
'arX'arR1H
I
if2contador^23
C
return2false3H
I
else
C
return2true3H
I
I
6/
J nuestra aplicacin uedara0
class App.iclo2
C
C
int entero,in'erido,cam*ia,opcionH
*oolean primoH
)ystem.out.println2FIngrese un entero de 'arios digitosF3H
enteroXLeer.datoInt23H
.iclo2 unoXne; .iclo22entero3H
opcionX0H
;(ile2opcionGXV3
C
)ystem.out.println2FKue desea (acer7 digite opcionF3H
)ystem.out.println2F10 Aer numero in'ertidoF3H
)ystem.out.println2F20 Aer numero con pares reempla%ados por SF3H
)ystem.out.println2FT0 Aer si el numero es primoF3H
)ystem.out.println2FV0 )alirF3H
opcionXLeer.datoInt23H
s;itc(2opcion3
C
case 10
in'ertidoXuno.in'ierte8umero23H
)ystem.out.println2FEl numero in'ertido es0 FRin'ertido3H
*rea?H
case 20
cam*iaXuno.cam*ia@igitos!aresS23H
)ystem.out.println2FEl numero con los pares cam*iados por S es0 FRcam*ia3H
*rea?H
case T0
primoXuno.primo23H
if2primoXXtrue3
C
)ystem.out.println2FEl numero es primoF3H
I
else
C
)ystem.out.println2FEl numero no es primoF3H
I
*rea?H
case V0
*rea?H
default0
)ystem.out.println2F)olo entre 1 y MF3H
I
I
I
I
E&ercicio 1
I. =eali%ar una clase llamada Entero la cual tendr como atri*uto un n-mero entero y los
siguientes m/todos0
a3 signo0 @e'ol'er0
- 1n 0 si el n-mero es cero
- 1n 1 si el n-mero es positi'o
- 1n -1 si el n-mero es negati'o
6(
7jemplo3
)i numero fuese -2T, de'ol'er -1
)i numero fuese 2M, de'ol'er 1
*3 ,alor-bsoluto0 @e'ol'er el 'alor a*soluto del n-mero
7jemplo3
)i numero fuese -2T, de'ol'er 2T
)i numero fuese 2M, de'ol'er 2M
c3 cantidadDeDi,isores0 @e'ol'er la cantidad de di'isores ue tiene el n-mero
7jemplo3
)i numero fuese W, de'ol'er T 2los ue di'iden a W son 1, T y W3
d3 !rimo0 de'ol'er true si el n-mero es primo, false en caso contrario 2El n-mero de*e ser
positi'o y slo tiene dos di'isores3
7jemplo3
)i numero fuese -M, de'ol'er false
)i numero fuese S, de'ol'er true
II. =eali%ar una aplicacin ue permita0
a3 .rear un o*"eto de tipo Entero
*3 9ostrar por pantalla mediante un men-, la utili%acin de todos los m/todos y solo salir del
sistema cuando el usuario lo desee.
E&ercicio 2
I. Agregar a la clase Entero los siguientes m/todos0
a3 sumaPar0 @e'ol'er la suma de los n-meros pares ue (ay entre 1 y el n-mero
7jemplo3
)i numero fuese W de'ol'er 20, pues los n-meros pares ue (ay entre 1 y W son 2RVRURQX20
*3 factorial0 @e'ol'er el factorial del n-mero
7jemplo3
)i numero fuese M de'ol'er 120, pues el factorial de M es 1[2[T[V[M
c3 digito1gual0 @e'ol'er la cantidad de dgitos del n-mero iguales a un dgito >
7jemplo3
)i numero fuese 1TT y el digito > fuese T, de'ol'er 2
II. 9odificar la aplicacin tal ue permita incorporar al men- estos m/todos.
E&ercicio
I. =eali%ar una clase llamada 2umeroEntero la cual tendr como atri*uto un n-mero entero > y
los siguientes m/todos0
a3 in,ertido0 de'ol'er el n-mero in'ertido
7jemplo3
)i numero g fuese 1VMU, de'ol'er UMV1
*3 digito3ayor0 @e'ol'er el dgito mayor del n-mero >
7jemplo3
)i el n-mero > fuese SS1UM, de'ol'er S
c3 rotar2umero0 @e'ol'er el n-mero > rotado % 'eces. !ara rotar una 'e% un n-mero, se de*e
sacar el -ltimo dgito y colocarlo al principio.
7jemplo3
)i el n-mero >XTV2M y % XT, de'ol'er V2MT
)olucin0 &endr ue rotar tres 'eces 2% 'ale tres3
La !rimera 'e% uedar MTV2
La segunda 'e% uedar 2MTV
La tercera 'e% uedar V2MT
62
d3 digito3enor0 @e'ol'er el dgito menor del n-mero >
7jemplo3
)i el n-mero > fuese SS1UM, de'ol'er 1
II. =eali%ar una aplicacin ue permita reali%ar el siguiente men- y slo con la opcin U se saldr0
8umero Entero
1. Ingresar un n-mero
2. 8-mero In'ertido
T. @gito 9ayor
V. =otar 8-mero
M. @igito 9enor
U. )alir
Eli"a Lpcin N
E&ercicio '
I. =eali%ar una clase llamada 2umeros la cual tendr como atri*uto dos n-meros entero y los
siguientes m/todos0
a3 digitos1guales0 de'ol'er la cantidad de dgitos iguales a un dgito % de un n-mero >
*3 mayor0 @e'ol'er el n-mero ue tiene mayor cantidad de dgitos iguales a un dgito >H en caso
ue tengan la misma cantidad, de'ol'er cualuiera de ellos.
7jemplo3
)i los n-meros fuesen VV y V0 y el digito fuese V de'ol'er VV
c3 !otencia0 @e'ol'er el primer n-mero ele'ado al segundo n-mero 2no puede utili%ar m/todo
po;3
7jemplo3
)i los n-meros fuesen 10 y T de'ol'er 1000
d3 ante!oner0 @e'ol'er un nue'o n-mero formado por0
El primer n-mero anteponi/ndole un dgito antes de un dgito par del n-mero
7jemplo3
)i numero fuese 1VMU y el dgito S, de'ol'er 1SVMSU
II. =eali%ar una aplicacin ue permita0
a3 .rear dos o*"etos de tipo Entero
*3 9ostrar lo siguiente0
L*"eto num1 num2
1 -- --
2 -- --
c3 9ostrar por pantalla para cada o*"eto los m/todos reali%ados en la clase 8umeros
'entencia de control iterativa do+(&ile
El do-;(ile es otro ciclo y todo lo ue podemos (acer con ;(ile tam*i/n se puede (acer
con esta sentencia, la gran diferencia se da en ue, en este ciclo siempre se ingresa la
primera 'e% y si la condicin se cumple el proceso se sigue repitiendo, au no se necesita
ue la condicin de ingreso se cumpla pre'iamente como en el ;(ile, au se ingresa
siempre la primera 'e%. El formato de la sentencia es0
doC
6)
instrucciones
I;(ile2condicin3H
hnica sentencia de control ue termina en punto y coma. Esta sentencia se utili%a a menudo
para 'alidacin de informacin, ya ue permite la captura y 'erificacin al interior del
*loue do-;(ile. La 'alidacin de la informacin es la forma de asegurarse ue los datos
ingresados por el usuario correspondan con los solicitados, por e"emplo si se pide la edad
de un alumno de educacin superior, esta de*era estar entre unos 1U y U0 aOos, si el
usuario ingresara M aOos este 'alor de*era ser rec(a%ado y 'uelto a solicitar al usuario,
'eamos el e"emplo0
doC
)ystem.out.println2+Ingrese edad del alumno,3H
edadXLeer.datoInt23H
I;(ile2edad]1U`èdadÛ03H
8tese ue si la edad es menor ue 1U o mayor ue U0 la condicin se (ace 'erdadera por
lo tanto el ciclo se repite.
,alidacin
Ltro uso com-n para esta sentencia es la 'alidacin o filtracin de 'alores generados de
forma aleatoria pero dentro de un rango determinado. 6.mo generamos 'alores en forma
aleatoria7 !ara ello de*emos recordar el m/todo random23 de la clase 9at(, el cual genera
'alores reales entre 0 y menores de 1. !ero en t/rminos generales los 'alores ue uno
necesita no estn en este rango, por esto de*emos, mediante operaciones matemticas,
producir la generacin entre los 'alores ue necesitemos, e"emplo0 si ueremos generar
'alores entre 0 y W tenemos0
int 'alorX2int329at(.random23[103H::generacin entre 0 y W
int 'alorX2int329at(.random23[1003H::generacin entre 0 y WW
int 'alorX2int329at(.random23[10003H::generacin entre 0 y WWW
6Ku/ podemos (acer para ue la generacin sea entre 0 y 107 Aeamos ue ocurre cuando
multiplicamos el m/todo por M 6Ku/ entrega7 Entregara 'alores entre 0 y V 6y si
multiplicamos por 2M7 Entregara 'alores entre 0 y 2V. Entonces se puede concluir ue
de*emos sumarle siempre 1 al 'alor m>imo ue ueremos generar para ue el m/todo lo
entregue. As si deseamos generar entre 0 y 10 tenemos0
int 'alorX2int329at(.random23[210R133H::generacin entre 0 y 10
A(ora ue pasara si el rango deseado est entre 1 y 10. La -nica forma de (acer ue el
rango mnimo sea mayor ue cero ser sumando el 'alor mnimo ue deseamos, e"emplo0
int 'alorX2int329at(.random23[210R13R13H::generacin entre 1 y 67.
64
!odemos o*ser'ar ue, cuando el m/todo entrega cero, este multiplicado por cualuier cosa
es cero, ms uno nos de'ol'er 1. !ero cuando genera el 'alor mayor multiplicado por 11 y
ms uno nos de'ol'er 11 y nosotros ueramos entre 1 y 10. !or lo tanto de*emos restar
este 'alor mnimo al elemento multiplicati'o, e"emplo0
int 'alorX2int329at(.random23[210R1-13R13H::generacin entre 1 y 10.
)i e>presamos esto como formula general tendremos0
int ,alor45int653ath%random56#5,alor7maximo819,alor7minimo68,alor7minimo6
Esta e>presin podemos utili%arla para generar n-meros enteros en el rango ue deseemos.
!ero esta e>presin no es capa% de filtrar, por e"emplo 6u/ pasa si uiero generar entre 1 y
2M pero no uiero 'alores m-ltiplos de M7
int 'alorX2int329at(.random23[22MR1-13R13H::generacin de 'alores entre 1 y 2M
Basta au la generacin es de todos los enteros entre 1 y 2M pero podemos utili%ar un do-
;(ile para filtrar el rango deseado0
int 'alorH
doC
'alorX2int329at(.random23[22MR1-13R13H::generacin de 'alores entre 1 y 2M
I;(ile2'alor\MXX03H
Los elementos generados a(ora corresponden al rango reuerido, ya ue cuando los 'alores
sean m-ltiplos de M se repetir el ciclo, generando un nue'o 'alor (asta ue no sea m-ltiplo
y en ese caso pasara el ciclo.
Aeamos un e"emplo donde utilicemos esta sentencia0 .onstruir una clase llamada
&ra*a"ador ue tiene los siguientes atri*utos0 nom*re, edad, se>o, 'alorN(ora,
(orasNnormales, (orasNe>tras. J los m/todos get, set, constructores y los siguientes
m/todos customer0
sueldo<ruto230 m/todo ue de'ol'er el sueldo *ruto, el ue corresponde a al
producto del 'alor de la (ora por las (oras normales mas el 'alor de la (ora e>tra
por la cantidad de (oras e>tras tra*a"adas.
afp230 m/todo ue de'ol'er el monto a pagar de A#! 21T\3.
isapre230 m/todo ue de'ol'er el monto a pagar de Isapre 2S\3.
sueldoLiuido230 m/todo ue de'ol'er el monto a pagar al tra*a"ador 2sueldo *ruto
menos A#! e Isapre.
.onstruir adems una aplicacin ue permita ingresar los datos necesarios 2'alidndolos3
para crear un o*"eto y luego se pueda mediante un men- 'er su sueldo *ruto y luido, A#!
e Isapre. )olo se de*e salir cuando el usuario lo desee. .onsidere la (ora e>tra un M0\ ms
ue la normal, "ornadas de 200 (oras mensuales y un sueldo mnimo de P1U0.000.
@esarrollo
En este e"ercicio estamos usando el nom*re del tra*a"ador ue corresponde a 'arios
caracteres 2pala*ras3 y estos en 4a'a pertenecen a las 'aria*les referenciadas u o*"etos ya
ue pertenecen a la clase )tring ue 'i'e dentro del 4a'a.lang.
65
1n pro*lema ue siempre se presenta con los nom*res de los atri*utos, es ue de*en ser
distintos a los de los parmetros, pero de*o *uscar nom*res ue me indiuen fcilmente a
uien se refieren, para e'itar este pro*lema e>iste la +referencia t(is, la cual permite ue
nom*res de parmetros y atri*utos sean iguales, por e"emplo si mis atri*utos son nom*re y
edad el constructor uedara0
&ra*a"ador2)tring nom*re, int edad3
C
t(is.nom*reXnom*reH
t(is.edadXedadH
I
Lo ue se est diciendo con la referencia t(is es ue +a este, el ue marca la referencia se
est asignado el ue llega por parmetro y por ende siempre el referenciado por el t(is ser
el atri*uto.
=etomando el e"ercicio nuestra parte *sica de la clase plano uedara0
class &ra*a"ador
C
pri'ate int edad,'alorN(ora,(orasNnormales,(orasNe>trasH
pri'ate )tring nom*reH
pr'ate c(ar se>oH

&ra*a"ador2int edad,int 'alorN(ora,int (orasNnormales,int (orasNe>tras,)tring nom*re,c(ar se>o3
C
t(is.edadXedadH
t(is.'alorN(oraX'alorN(oraH
t(is.(orasNnormalesX(orasNnormalesH
t(is.(orasNe>trasX(orasNe>trasH
t(is.nom*reXnom*reH
t(is.se>oXse>oH
I
&ra*a"ador23
C
I
int getEdad23
C
return2edad3H
I
int getAalorN(ora23
C
return2'alorN(ora3H
I
int getBorasNnormales23
C
return2(orasNnormales3H
I
int getBorasNe>tras23
C
return2(orasNe>tras3H
I
)tring get8om*re23
C
return2nom*re3H
I
c(ar get)e>o23
C
return2se>o3H
6!
I
'oid setEdad2int edad3
C
t(is.edadXedadH
I
'oid setAalorN(ora2int 'alorN(ora3
C
t(is.'alorN(oraX'alorN(oraH
I
'oid setBorasNnormales2int (orasNnormales3
C
t(is.(orasNnormalesX(orasNnormalesH
I
'oid setBorasNe>tras2int (orasNe>tras3
C
t(is.(orasNe>trasX(orasNe>trasH
I
'oid set)e>o2c(ar se>o3
C
t(is.se>oXse>oH
I
I
J los m/todos sern0

int sueldo<ruto23
C
int sH
sX2int32'alorN(ora[(orasNnormalesR'alorN(ora[(orasNe>tras[1.M3H
return2s3H
I
int afp23
C
int aH
aXsueldo<ruto23[1T:100H
return2a3H
I
int isapre23
C
int iH
iXsueldo<ruto23[S:100H
return2i3H
I
int sueldoLiuido23
C
int sH
sXsueldo<ruto23-afp23-isapre23H
return2s3H
I
J finalmente en la aplicacin, la no'edad esta en las 'alidaciones, para las cuales de*emos
esta*lecer los rangos en los cuales son 'alidos los 'alores ingresados por el usuario0
edad, para tra*a"ar se necesitan como mnimo 1Q aOos y como m>imo UM si es
(om*re y U0 si es mu"er.
Aalor de la (ora, solo tiene lmite inferior y es el sueldo mnimo di'ido por la
"ornada mensual 21U0.000:200XQ003.
Las (oras normales pueden ser 0 (asta 200.
66
Las (oras e>tras 'an de 0 a VM.
El se>o solo puede ser YBZ o Y9Z
J el nom*re por a(ora no podemos 'alidarlo
El resto del proceso para la construccin de la aplicacin es igual sal'o ue
reempla%aremos los ;(ile por do-;(ile y 'eremos las 'enta"as ue presenta su uso.
class App&ra*a"ador
C
C
int edad,'alorN(ora,(orasNnormales,(orasNe>tras,opcionH
)tring nom*reH
c(ar se>oH
doC
)ystem.out.println2FIngrese se>o del tra*a"adorF3H
se>oXLeer.dato.(ar23H
I;(ile2se>oGXb9b__se>oGXbBb3H
if2se>oXXb9b3
C
doC
)ystem.out.println2FIngrese edad de la tra*a"adoraF3H
I;(ile2edad]1Q`èdadÛ03H
I
else
C
doC
)ystem.out.println2FIngrese edad del tra*a"adorF3H
I;(ile2edad]1Q`èdadÛM3H
I
doC
)ystem.out.println2FIngrese 'alor (ora del tra*a"adorF3H
'alorN(oraXLeer.datoInt23H
I;(ile2'alorN(ora]Q003H
doC
)ystem.out.println2FIngrese (oras normales tra*a"adasF3H
(orasNnormalesXLeer.datoInt23H
I;(ile2(orasNnormales]0``(orasNnormales^2003H
doC
)ystem.out.println2FIngrese (oras e>tras tra*a"adasF3H
(orasNe>trasXLeer.datoInt23H
I;(ile2(orasNe>tras]0``(orasNe>tras^VM3H
)ystem.out.println2FIngrese nom*re del tra*a"adorF3H
nom*reXLeer.dato23H
&ra*a"ador unoXne; &ra*a"ador2edad,'alorN(ora,(orasNnormales,(orasNe>tras,nom*re,se>o3H
doC
)ystem.out.println2FKue desea 'er del tra*a"ador, digite opcionF3H
)ystem.out.println2F10 )ueldo *rutoF3H
)ystem.out.println2F20 A#!F3H
)ystem.out.println2FT0 IsapreF3H
)ystem.out.println2FV0 )ueldo liuidoF3H
)ystem.out.println2FM0 salirF3H
s;itc(2opcion3
C
case 10
)ystem.out.println2FEl sueldo *ruto es0 FRuno.sueldo<ruto233H
*rea?H
6-
case 20
)ystem.out.println2FLa A#! es0 FRuno.afp233H
*rea?H
case T0
)ystem.out.println2FLa isapre es0 FRuno.isapre233H
*rea?H
case V0
)ystem.out.println2FEl sueldo liuido es0 FRuno.sueldoLiuido233H
*rea?H
case M0
*rea?H
default0
)ystem.out.println2F)olo entre 1 y M F3H
I
I;(ile2opcionGXM3H
I
I
!odemos o*ser'ar ue en este caso no es necesario iniciali%ar la 'aria*le opcin, ya ue
como es un do-;(ile, siempre entrara la primera 'e%. &am*i/n podemos 'er, ue para
mostrar los resultados no es necesario declarar una 'aria*le para de"arlo, y luego mostrarlo,
se puede (acer directamente. &am*i/n, es necesario destacar ue las 'aria*les edad y se>o
estn relacionadas, por lo tanto la edad depende del se>o, entonces de*o conocer el se>o
para poder e'aluar si la edad es la correcta.
6.mo de*eramos modificar esta aplicacin si ueremos ingresar muc(os tra*a"adores7
Lo ue deseamos (acer es repetir todo el proceso, pero para otros datos, esto significa ue
de*emos repetir no solo el men- sino ue tam*i/n el ingreso de la informacin y la
creacin del o*"eto, agregando alg-n mensa"e para ue el usuario tome la determinacin si
desea crear un nue'o tra*a"ador 2o*"eto3 o salir. La aplicacin uedara0
class App&ra*a"ador
C
C
int edad,'alorN(ora,(orasNnormales,(orasNe>tras,opcion,o!cion2H//opcion' para el nue%o do84hile
)tring nom*reH
c(ar se>oH
do://do para repetir todo
doC
if2se>oXXb9b3
C
doC
I
else
C
doC
I
doC
6#
doC
doC
nom*reXLeer.dato23H
doC
s;itc(2opcion3
C
case 10
*rea?H
case 20
*rea?H
case T0
*rea?H
case V0
*rea?H
case M0
*rea?H
default0
I
I;(ile2opcionGXM3H
System%out%!rintln5;Desea ingresar otro traba&ador< si digite 1;6=//mensaje para repetir el ciclo
o!cion24Leer%dato1nt56=
>?hile5o!cion24416=//fin del ciclo que repite todo
I
I
)e (a destacado en negrito lo insertado en el programa para permitir la creacin de muc(os
o*"etos tantos como el usuario uiera, pero de*emos tener presente ue el sistema solo
tendr en memoria un o*"eto, la informacin ingresada pisa a la anterior y esta se pierde,
por a(ora no tenemos forma de guardarla, esto significa ue solo tememos en nuestra
memoria los datos del o*"eto reci/n creado 2el ultimo3.
6.mo podramos guardar datos acumulati'os de los tra*a"adores ue ya (emos re'isado7
.omo por e"emplo sueldo promedio, cuantas mu"eres tra*a"an, nom*re del tra*a"ador ms
'ie"o, etc. !ara esto de*emos declarar 'aria*les ue mantengan los datos y se 'ayan
reno'ando en la medida ue se ingresa ms informacin. !ero de*emos colocar estas
'aria*les donde el o*"eto de tra*a"o aun e>ista y podamos rescatar los datos. Estos
-/
resultados de*ern mostrarse una 'e% ue no se ingrese ms informacin, en otras pala*ras
cuando el usuario diga ue no uiere crear ms tra*a"adores. Aeamos los cam*ios de la
aplicacin para este pro*lema0
class App&ra*a"ador
C
C
int edad,'alorN(ora,(orasNnormales,(orasNe>tras,opcion,opcion2H
int sueldo7!romedio4@<edad7,ie&o4@<cantidad7mu&eres4@<cantidad7traba&adores4@=
int sueldo7total4@=
String nombre7,ie&o4;;=
)tring nom*reH
c(ar se>oH
doC
doC
if2se>oXXb9b3
C
doC
I
else
C
doC
I
doC
doC
doC
nom*reXLeer.dato23H
doC
s;itc(2opcion3
C
case 10
*rea?H
-(
case 20
*rea?H
case T0
*rea?H
case V0
*rea?H
case M0
*rea?H
default0
I
I;(ile2opcionGXM3H
7n esta parte tenemos creado el objeto y debemos capturar los datos que queremos antes de que el usuario parta con el otro objeto
cantidad7traba&adores88=contamos todos los trabajadores que se han ingresado
sueldo7total4sueldo7total8uno%sueldoLi.uido56=//sumamos todos los sueldos obtenidos para despus obtener el promedio
if5uno%getSexo5644A3A6//contamos si es mujer
:
cantidad7mu&eres88=
>
if5uno%getEdad56Bedad7,ie&o6//preguntamos si la edad es mayor si es as la guardamos
:
edad7,ie&o4uno%getEdad56=
nombre7,ie&o4uno%get2ombre56=
>
)ystem.out.println2F@esea ingresar otro tra*a"ador, si digite 1F3H
opcion2XLeer.datoInt23H
I;(ile2opcion2XX13H
//desde aqu hacia abajo ya no se puede de%ol%er a crear otro objeto por lo tanto se puede mostrar los datos acumulati%os
sueldo7!romedio4sueldo7total$cantidad7traba&adores=
System%out%!rintln5;El sueldo !romedio es: ;8sueldo7!romedio6=
System%out%!rintln5;Las mu&eres .ue traba&an son: ;8cantidad7mu&eres6=
System%out%!rintln5;El nombre del traba&ador mas ,ie&o es: ;8nombre7,ie&o6=
I
I
8ue'amente se (a de"ado en negrito las modificaciones necesarias para la o*tencin de la
informacin acumulada del ingreso de m-ltiples datos.
'entencia iterativa -or
El for es la -ltima sentencia de control iterati'a ue 'eremos, y (ace lo mismo ue el ;(ile
y el do-;(ile, las diferencias estn ms en el formato ue en otra cosa. El formato de la
sentencia for es el siguiente0
for2condicin o condiciones de inicio = condicin de comparacin = condicin o condiciones de incremento o decremento3
C
<loue ue se de*e e"ecutar, si la condicin de comparacin se cumple
I
En la condicin de inicio se puede declara e iniciali%ar simultneamente una o ms
'aria*les, las cuales solo se consideran al ingresar al ciclo y nunca ms. Luego el sistema
pasa a la condicin de comparacin y si esta se cumple se ingresa la *loue del ciclo,
e"ecutando todas las instrucciones declaradas, cuando el sistema encuentra el par/ntesis ue
cierra el ciclo, el sistema retorna a las condiciones incrementado o decrementando la o las
'aria*les u*icadas en las condiciones de incremento o decremento 2en el 'alor declarado en
-2
ellas3 y 'uel'e a 'erificar si la condicin de comparacin se cumple o no, y dependiendo de
esto, continua con el ciclo o se lo salta, para continuar en la instruccin siguiente al
par/ntesis de lla'e ue cierra el ciclo.
En un ciclo for las tres condiciones 'an separadas por punto y coma. )i (ay mas de una
condicin estas se separan por comas. Adems algunas o todas las condiciones pueden ser
omitidas y el ciclo funcionara, por e"emplo for2HH3 corresponde a un ciclo infinito ya ue no
tiene final.
Aeamos un e"emplo de cmo se utili%a y apro'ec(emos de comparar esta sentencia con las
anteriores, para esto utilicemos el m/todo ue determina si un n-mero es primo o no.
*oolean primo23//con while
C
;(ile2'ar]Xentero3
C
if2entero\'arXX03
C
I
'arX'arR1H
I
if2contador^23
C
return2false3H
I
else
C
return2true3H
I
I
*oolean primo223//con do-while
C
doC
if2entero\'arXX03
C
I
'arX'arR1H
I;(ile2'ar]Xentero3H
if2contador^23
C
return2false3H
I
else
C
return2true3H
I
I
*oolean primoT23//con for
C
int contadorX0H
for2int 'arX1H'ar]XenteroH'arRR3
C
if2entero\'arXX03
C
I
-)
I
if2contador^23
C
return2false3H
I
else
C
return2true3H
I
I
Esta sentencia se utili%a muc(o para tra*a"ar con la ms simple de las estructuras de datos,
los arreglos.
.rreglos
En este curso solo 'eremos los arreglos ms simples ue son los de primiti'os y
unidimensionales, pero 6u/ es un arreglo7 !ara responder a esta pregunta pensemos ue si
deseamos construir una clase llamada .urso ue tenga como atri*utos las notas promedio
de cada uno de los alumnos de un curso 2T03 de*o declarar T0 atri*utos y si la clase se
llamara AntonioAaras de*era declarar cerca de T00 atri*utos y si se llamara @uoc se (ace
aun ms comple"o el pro*lema. <ueno los arreglos 'ienen a solucionar este pro*lema ellos
son una estructura de datos ue permite guardar en su interior muc(os datos pero de un
mismo tipo. Es una especie de metro, donde en cada carro solo puede ingresar una persona
y si ingreso otra la primera se pierde. E"emplo si tenemos un arreglo de largo 20 lo ue
tendremos es lo siguiente0
@onde en cada celda 2ca"a3 ca*e un solo 'alor y todos los 'alores de*en ser del mismo tipo.
!ara representar el arreglo de*emos asignarle un nom*re por e"emplo0 +notas, y se utili%an
los par/ntesis de corc(etes para indicar ue es un arreglo 2D E3, as notasDE representa un
arreglo. Las celdas o ca"as del arreglo por definicin tienen asignado un ndice ue
representa su posicin respecto al arreglo y parte siem!re de @. !or lo tanto si decimos
notasDME estamos (aciendo mencin a la celda n-mero U del arreglo llamado notas. 1n
arreglo puede tener el tamaOo ue ueramos no (ay restriccin y este largo o tamaOo
de*emos entregarlo en el momento de crear el arreglo. Es importante indicar ue los
arreglos son o*"etos por ende se de*en crear como tales, e"emplo0
dou*le DEnotasH
notasX ne; notasD20EH
o *ien
dou*le DEnotasXne; notasD20EH
Lo ue estamos diciendo, es ue tenemos un arreglo de datos dou*le de largo 20. .uando
uno crea este o*"eto de inmediato se crea un atri*uto de este o*"eto llamado +lengt(, ue
contiene el largo del arreglo, por e"emplo notas.lengt( tendr un 'alor de 20 el cual puede
-4
ser de'uelto cada 'e% ue llamemos este atri*uto. .ada 'e% ue creamos un arreglo este
iniciali%a sus celdas, en los 'alores por defecto del tipo del arreglo, as nuestro arreglo notas
uedara0
0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
!ara poder llenarlo con 'alores es necesario recorrerlo e ir ingresando uno por uno, por
e"emplo0
for2int iX0Hi]20HiRR3
C
)ystem.out.println2+Ingrese una nota,3H
notasDiEXLeer.dato@ou*le23H
I
.omo 'emos en cada 'uelta el 'alor de i ue parte en la celda 0 'a aumentando de uno en
uno permitiendo el ingreso de los 'alores en forma ordenada en cada celda. El +i, se
conoce como ndice e indica la posicin de la celda. @espu/s de llenar el arreglo uedara
algo como0
T.0 V.V 2.0 S.0 T.T U.1 1.0 T.0 V.S 2.Q 1.0 M.1 T.0 V.T 1.0 U.T S.0 1.0 T.W V.V
0 1 2 T V M U S Q W 10 11 12 1T 1V 1M 1U 1S 1Q 1W
Entonces 6.unto 'ale notasDVE7 <uscamos la posicin V y tenemos T.T y si preguntamos
en u/ posicin encontramos un U.T si *uscamos la nota 'emos ue el ndice ue le
corresponde es el 1M, si *uscamos ue ndice coincide con la nota, encontramos ue en la
posicin 2 tenemos como nota 2.
La importancia ue presentan los arreglos, es ue a(ora ya no necesitamos muc(os
atri*utos para las notas sino ue uno solo, un arreglo. Es necesario destacar ue para llenar,
mostrar o recorrer un arreglo es necesario (acerlo mediante un ciclo y en t/rminos
generales el ms usado para este fin es el for.
.onstruyamos una clase ue tenga como atri*uto un arreglo de notas de largo T0 y los
promedio230 este m/todo de'ol'er el promedio del curso.
apro*ados230 este m/todo de'ol'er cuantos alumnos apro*aron el curso.
notaS230 este m/todo de'ol'er cuantos alumnos o*tu'ieron nota S.
promedioAlumnosApro*ados230 este m/todo de'ol'er el promedio de los alumnos
apro*ados.
.onstruir, una aplicacin donde se ingresen las notas de los alumnos se cree el o*"eto y se
muestre mediante un men-0
1. Aer arreglo de notas
2. Aer promedio de los alumnos
T. Aer cantidad de apro*ados
V. Aer cantidad de alumnos con nota S.
M. Aer promedio de los alumnos apro*ados
U. )alir
El usuario de*e salir solo cuando /l lo desee.
-5
@esarrollo
A(ora el atri*uto es un arreglo y si se conoce su largo se puede declarar y construir en la
declaracin de atri*utos pero si no se conoce el largo, solo se de*e declarar y construirlo en
el constructor. A su 'e% en el constructor se de*e entregar la informacin ue llega por
parmetro al atri*uto arreglo y esto se de*e (acer mediante un for donde se pase la
informacin una a una, celda a celda. Aeamos cmo ueda la parte *sica de la clase plano0
class .urso
C
pri'ate dou*leDEnotasH//declaraci0n de un arreglo, se asume que no se conoce el largo

.urso2dou*leDEnot3//llega por parmetro un arreglo lleno con informaci0n desde la aplicaci0n
C
notasXne; dou*leDnot.lengt(EH//se crea el arreglo del tama9o del arreglo que llega por parmetro
for2int iX0Hi]not.lengt(HiRR3
C
notasDiEXnotDiEH//se traspasa la informaci0n celda a celda
I
I
.urso23
C
I
dou*leDE get8otas23//mtodo que de%uel%e un arreglo de double
C
return2notas3H
I
'oid set8otas2dou*le nue'aNnota,int posicion3//mtodo que modifica una celda especifica del arreglo por un nue%o %alor
C
notasDposicionEXnue'aNnotaH
I
'oid set8otas2dou*leDEnot3//mtodo que modifica todo el arreglo cambindolo por uno nue%o
C
C
notasDiEXnotDiEH
I
I
I
)e puede o*ser'ar ue e>isten dos m/todos con el mismo nom*re +%oid set:otas,, pero
cam*ian en los parmetros, esto tam*i/n se (a*a 'isto en los constructores, y se conoce
como sobrecarga de m/todos o de constructores. !ara ue e>ista so*recarga los m/todos
de*en llamarse iguales y solo de*en diferir en los tipos de los parmetros o en la cantidad
de ellos o en el orden de ellos.
Aeamos a(ora los m/todos0
9/todo promedio23, para calcular el promedio de*emos recorrer el arreglo sumando sus
notas y cuando se termine de sumar di'idir por el numero de notas 2largo del arreglo3.
dou*le promedio23
C
dou*le sumaX0H
for2int iX0Hi]notas.lengt(HiRR3
C
sumaXsumaRnotasDiEH
I
return2suma:notas.lengt(3H
I
-!
9/todo apro*ados23, para sa*er cuntos alumnos apro*aron de*emos recorrer el arreglo y
preguntar si la nota es igual o superior a T.WM y si es as contar a este alumno.
int apro*ados23
C
int cantidadX0H
C
if2notasDiE^XT.WM3
C
cantidadRRH
I
I
return2cantidad3H
I
9/todo notaS23, para sa*er cuntos alumnos tu'ieron nota S de*emos recorrer el arreglo y
preguntar si su nota es igual a S, si es as contarlo.
int notaS23
C
int cantidadX0H
C
if2notasDiEXXS3
C
cantidadRRH
I
I
return2cantidad3H
I
9/todo promedioAlumnosApro*ados23, para sa*er el promedio de los alumnos apro*ados,
de*emos recorrer el arreglo sumando las notas de los alumnos ue o*tu'ieron un T.WM o
ms y contar el numero de estos alumnos, para ue una 'e% terminado el ciclo, calcular el
promedio, di'idiendo la suma por el n-mero de alumnos apro*ados.
dou*le promedioAlumnosApro*ados23
C
dou*le sumaX0, cantidadX0H
C
if2notasDiE^XT.WM3
C
sumaXsumaRnotasDiEH
cantidadRRH
I
I
return2suma:cantidad3H
I
Es importante destacar ue para cualuier cosa ue se uiera (acer con el arreglo es
necesario recorrerlo y esto se (ace mediante un ciclo 2generalmente for3.
.onstruyamos a(ora nuestra aplicacin0
class App.urso
C
C
dou*leDEnotXne; dou*leDT0EH
int opcion,opcion2H
doC
-6
C
doC
)ystem.out.println2FIngrese nota FR2iR133H
notDiEXLeer.dato@ou*le23H
I;(ile2notDiE]1``notDiE^S3H
I
.urso unoXne; .urso2not3H
doC
)ystem.out.println2FKue desea 'er, digite opcionF3H
)ystem.out.println2F10 Aer arreglo ingresadoF3H
)ystem.out.println2F20 Aer promedio del cursoF3H
)ystem.out.println2FT0 Aer cantidad de apro*adosF3H
)ystem.out.println2FV0 Aer cuantos alumnos tienen SF3H
)ystem.out.println2FM0 Aer promedio de los alumnos apro*adosF3H
)ystem.out.println2FU0 )alirF3H
s;itc(2opcion3
C
case 10
)ystem.out.println2FEl arreglo ingresado esF3H
C
)ystem.out.print2uno.get8otas23DiERFHF3H//un arreglo se puede mostrar as directamente o bien solo declarar otro arreglo
// para recibirlo y este recorrerlo
I
)ystem.out.println2F F3H
*rea?H
case 20
)ystem.out.println2FEl promedio del curso es0 FRuno.promedio233H
*rea?H
case T0
)ystem.out.println2FLa cantidad de alumnos pro*ados es0 FRuno.apro*ados233H
*rea?H
case V0
)ystem.out.println2FLa cantidad de alumnos con S es0 FRuno.notaS233H
*rea?H
case M0
)ystem.out.println2FEl promedio de los apro*ados es0 FRuno.promedioAlumnosApro*ados233H
*rea?H
case U0
*rea?H
default0
)ystem.out.println2Fsolo entre 1 y UF3H
I
I;(ile2opcionGXU3H
)ystem.out.println2F@esea ingresar las notas de otro curso, si digite 1F3H
I;(ile2opcion2XX13H
I
I
Aeamos otra situacin, a(ora construir una clase llamada Aleatoria, donde se tiene como
atri*uto un arreglo de enteros de largo indicado por el usuario y en'iado por parmetro y
llenado en el constructor en forma aleatoria entre 0 y el mismo 'alor del largo y los
siguientes m/todos0 constructores, get, set y los customer0
coinciden230 m/todo ue de'uel'e un nue'o arreglo con los elementos ue
coinciden con el ndice.
pares230 m/todo ue de'uel'e un nue'o arreglo solo con elementos pares.
--
in'ertido230 m/todo ue de'uel'e un nue'o arreglo, pero con los elementos en orden
in'erso.
sin=epeticion230 m/todo ue de'uel'e un nue'o arreglo sin elementos repetidos.
ordenado230 m/todo ue de'uel'e un nue'o arreglo pero con los elementos
ordenados ascendentemente.
.onstruir una aplicacin con men-, ue permita 'er todos los m/todos incluido el arreglo
generado y solo salga cuando el usuario uiera, preguntado si uiere crear otro o*"eto antes.
@esarrollo
En esta situacin, el arreglo solo se puede declarar como atri*uto, ya ue su largo solo ser
conocido en el constructor, lugar donde se de*er crear y llenar seg-n lo solicitado. La
parte *sica de nuestra clase plano uedara0
class Aleatoria
C
pri'ate intDEarregloH//solo podemos declarar el arreglo ya que no conocemos su largo

Aleatoria2int largo3//el largo del arreglo llega por parmetro desde la aplicaci0n
C
arregloXne; intDlargoEH//conocido el largo podemos crear el arreglo
for2int iX0Hi]largoHiRR3
C
arregloDiEX2int329at(.random23[2largoR133H//llenamos el arreglo en forma aleatoria entre # y el %alor del largo
I
I
Aleatoria23
C
I
intDE getArreglo23
C
return2arreglo3H
I
'oid setArreglo23//solo un mtodo matador ya que el arreglo se llena aleatoriamente y solo se deber modificar entero
C
for2int iX0Hi]arreglo.lengt(HiRR3
C
arregloDiEX2int329at(.random23[2arreglo.lengt(R133H
I
I
I
Los m/todos entonces sern0
coinciden230 se de*e *uscar a todos los elementos 2'alor contenido en la celda3 ue sea
igual al ndice 2posicin dentro del arreglo3 y guardar el elemento en un nue'o arreglo, el
cual ser de'uelto.
intDE coinciden23
C
int cuentaX0,?X0H

for2int iX0Hi]arreglo.lengt(HiRR3//recorro el arreglo
C
if2iXXarregloDiE3//preguntamos si el ndice es igual al elemento
C
cuentaRRH//contamos las coincidencias
I
-#
I
intDEnue'oXne; intDcuentaEH//conocida la cantidad de coincidencias creamos el arreglo del tama9o adecuado
for2int iX0Hi]arreglo.lengt(HiRR3//%ol%emos a recorrer el arreglo
C
if2iXXarregloDiE3//preguntamos nue%amente por las coincidencias
C
nue'oD?EXiH//pasamos ahora la informaci0n al nue%o arreglo
?RRH//hacemos caminar el ndice del nue%o arreglo para incorporar la nue%a informacion
I
I
return2nue'o3H
I
El m/todo pares23, es similar al anterior, contamos el n-mero de elementos pares ue tiene
el arreglo, con esta informacin creamos un nue'o arreglo y 'ol'emos a recorrer el arreglo
a(ora para llenar el nue'o con los elementos pares.
intDE pares23
C
int cuentaX0,?X0H

C
if2arregloDiE\2XX03
C
cuentaRRH
I
I
intDEnue'oXne; intDcuentaEH
C
if2arregloDiE\2XX03
C
nue'oD?EXarregloDiEH
?RRH
I
I
return2nue'o3H
I
El siguiente m/todo es in'ertido23, donde de*emos de"ar los elementos del primer arreglo
pero al re'/s, o sea en la posicin cero de*emos de"ar el -ltimo elemento y as
sucesi'amente. 8tese ue no se pide ue mostremos el arreglo de atrs (acia adelante. Lo
ue (acemos es, simultneamente recorrer un arreglo de atrs (acia adelante y el otro
normalmente.
intDE in'ertido23
C
intDEnue'oXne; intDarreglo.lengt(EH

for2int iXarreglo.lengt(-1,?X0Hi^X0Hi--,?RR3
C
nue'oD?EXarregloDiEH
I
return2nue'o3H
I
El siguiente m/todo sin=epeticion23, de*e de'ol'er otro arreglo pero sin elementos
repetidos, para ello primero crearemos un arreglo 2arreglo de paso3, del mismo tamaOo del
inicial, donde pasaremos y contaremos los elementos ue no estn repetidos, para luego
#/
crear el arreglo definiti'o con esta informacin, y traspasar los elementos no repetidos a
este. !ara (acer esto, tomaremos el primer elemento y lo pasaremos directamente al arreglo
de paso, para luego tomar el segundo elemento y re'isar si ya esta pasado, si no lo est, lo
pasamos y contamos y si lo est continuamos con el siguiente elemento.
intDE sin=epeticion23
C
intDEpasoXne; intDarreglo.lengt(EH
int ?X0,contX0H
C
contX0H
for2int "X0H"]?H"RR3
C
if2arregloDiEXXpasoD"E3
C
contRRH
I
I
if2contXX03
C
pasoD?EXarregloDiEH
?RRH
I
I
intDEnue'oXne; intD?EH
for2int iX0Hi]nue'o.lengt(HiRR3
C
nue'oDiEXpasoDiEH
I
return2nue'o3H
I
#inalmente el -ltimo m/todo ordenado23, de*e de'ol'er un nue'o arreglo pero con sus
elementos ordenados en forma ascendente, para esto utili%aremos el m/todo de la *ur*u"a
ue consiste en tomar el primer elemento del arreglo y compararlo con el ue sigue y si este
es menor cam*iarlos de posicin, si no lo es se de"an en las mismas posiciones, luego con
el mismo primer elemento lo comparo con el su* siguiente y si este es menor los cam*io de
posicin y as sucesi'amente. .omo no deseamos modificar el atri*uto sacaremos una
copia, con la cual tra*a"aremos.
intDE ordenado23
C
intDEcopiaXne; intDarreglo.lengt(EH
int au>H
C
copiaDiEXarregloDiEH
I
for2int iX0Hi]copia.lengt(HiRR3
C
for2int "XiR1H"]copia.lengt(H"RR3
C
if2copiaDiE^copiaD"E3
C
au>XcopiaDiEH
copiaDiEXcopiaD"EH
copiaD"EXau>H
I
#(
I
I
return2copia3H
I
8uestra aplicacin de*er tener un men- y solo salir cuando el usuario uiera, pero de*er
preguntar si uiere crear otro arreglo.
class AppAleatoria
C
C
intDEmostrarH//se declara un arreglo para recibir y mostrar los arreglos de%ueltos por los mtodos
int largo,opcion,opcion2H
doC
doC//se %alida el largo del arreglo, este debe ser mayor que cero
)ystem.out.println2Fingrese largo del arregloF3H
largoXLeer.datoInt23H
I;(ile2largo]X03H
Aleatoria unoXne; Aleatoria2largo3H
doC
)ystem.out.println2FKue desea 'er7 digite opcionF3H
)ystem.out.println2F10 Aer arreglo generadoF3H
)ystem.out.println2F20 Aer arreglo con elementos ue coincidenF3H
)ystem.out.println2FT0 Aer arreglo con elementos paresF3H
)ystem.out.println2FV0 Aer arreglo con elementos in'ertidosF3H
)ystem.out.println2FM0 Aer arreglo con elementos sin repeticionF3H
)ystem.out.println2FU0 Aer arreglo con elementos ordenadosF3H
)ystem.out.println2FS0 )alirF3H
s;itc(2opcion3
C
case 10
mostrarXuno.getArreglo23H
for2int iX0Hi]mostrar.lengt(HiRR3
C
)ystem.out.print2mostrarDiERFHF3H
I
)ystem.out.println23H
*rea?H
case 20
mostrarXuno.coinciden23H
if2mostrar.lengt(XX03
C
)ystem.out.println2F8o (ay elementos coincidentesF3H
I
else
C
C
I
I
*rea?H
case T0
mostrarXuno.pares23H
if2mostrar.lengt(XX03
C
)ystem.out.println2F8o (ay elementos paresF3H
I
else
#2
C
C
I
I
*rea?H
case V0
mostrarXuno.in'ertido23H
C
I
*rea?H
case M0
mostrarXuno.sin=epeticion23H
C
I
*rea?H
case U0
mostrarXuno.ordenado23H
C
I
*rea?H
case S0
*rea?H
default0
)ystem.out.println2F)olo entre 1 y SF3H
I
I;(ile2opcionGXS3H
)ystem.out.println2F@esea crear otro arreglo7 digite 1 para )IF3H
I;(ile2opcion2XX13H
I
I
E&ercicio 1
.onstruir una clase llamada Arreglo2, ue tiene por atri*utos dos arreglos del tipo entero
del mismo largo 5!aralelos6, el primero de ellos ser generado en forma aleatoria entre -20
y 20 y el otro es llenado por el usuario y en'iado por parmetro. .onstruya los m/todos get,
set y constructores necesarios y los siguientes m/todos customer0
union230 m/todo ue de'uel'e un nue'o arreglo con los elementos ue pertenecen a
am*os arreglos atri*utos.
interseccion230 m/todo ue de'uel'e un nue'o arreglo con los elementos comunes a
am*os arreglos.
#)
complemento230 m/todo ue de'uel'e un nue'o arreglo con los elementos ue estn
en el primer arreglo pero no en el segundo.
.onstruir adems una aplicacin ue permita ingresar la informacin necesaria,
'alidndola, construir un o*"eto y mediante un men- muestre lo siguiente0
1. Aer arreglo generado e ingresado.
2. Aer unin de los dos arreglos.
T. Aer interseccin de los dos arreglos.
V. Aer complemento de los dos arreglos.
M. )alir.
El usuario solo de*e salir cuando lo desee y preguntar si desea tra*a"ar con dos nue'os
arreglos.
E&ercicio 2
.onstruir una clase llamada Llu'ia ue tiene como atri*utos los datos de llu'ia cada en
!uerto 9ontt durante los 12 meses de un aOo. El sistema contara con dos arreglos uno
llamado meses 2)tring3 ue tiene el nom*re de los meses del aOo y otro ue corresponde a
la llu'ia cada en cada mes 2largo 123, el cual ser llenado en forma aleatoria entre 0 y 2VM
milmetros. .onstruya los m/todos get, set y constructores necesarios y los siguientes
customer0
promedioLlu'ia.aidaAnual230 m/todo ue de'uel'e el promedio de la llu'ia cada
en el aOo.
mes9asLlu'ioso230 m/todo ue de'uel'e el mes ms llu'ioso.
totalAgua.aida230 m/todo ue de'uel'e el total de agua cada durante el aOo.
meses9asLlu'iosos230 m/todo ue de'uel'e un arreglo con el nom*re de los meses
en ue llo'i ms ue el promedio anual.
.onstruir adems una aplicacin ue permita ingresar la informacin necesaria,
'alidndola, construir un o*"eto y mediante un men- muestre lo siguiente0
1. Aer promedio de la llu'ia cada en el aOo.
2. Aer mes ms llu'ioso.
T. Aer total de agua cada durante el aOo.
V. Aer arreglo con los meses ue llo'i ms ue el promedio.
M. )alir.
El usuario solo de*e salir cuando lo desee y preguntar si desea tra*a"ar con otro aOo.
Clases colaboradoras
)e conoce como clases cola*oradoras, a clases pre'iamente creadas ya sea por uno o por la
)18, y ue son utili%adas muc(as 'eces en el tra*a"o de programacin o creacin de
soluciones informticas 2reutili%acin del cdigo3.
#4
Clase 'tring
La clase )tring es uno de los e"emplos ms claros de clases cola*oradoras, ella fue
construida por la )18 y da cuanta del mane"o de cadenas de caracteres 2pala*ras3. Esta
clase cuenta con un grupo de m/todos ue permite el mane"o de pala*ras, la api de esta
clase est disponi*le desde la pagina de la sun
2(ttp0::"a'a.sun.com:"2se:1.M.0:docs:api:"a'a:lang:)tring.(tml3. Los m/todos ms utili%ados
de esta clase son0
int o*"cadena.length230 @e'uel'e la longitud de la cadena.
c(ar o*"cadena.char-t2 int30 @e'uel'e el carcter ue encuentre en la posicin indicada
por el parmetro.
*oolean o*"cadena.e.uals2 L*"ect 30 .omprue*a ue dos instancias son iguales. En este
caso comprue*a ue el o*"eto dado como argumento sea de tipo )tring y contenga la
misma cadena de caracteres ue el o*"eto actual.
*oolean o*"cadena.e.uals1gnoreCase2 L*"ect 30 Es id/ntico al anterior, pero ignora
may-s. o min-s.
int o*"cadena.com!areTo2 )tring 3, int o*"cadena.com!areTo1gnoreCase2 )tring 30
@e'uel'e un entero menor ue cero si la cadena es alfa*/ticamente menor ue la dada
como argumento, cero si las dos cadenas son l/>ica mente iguales y un entero mayor
ue cero si la cadena es mayor.
.omprue*a si el comien%o o el final de la cadena actual coincide con la cadena pasada
como parmetro
*oolean o*"cadena.startsDith2 )tring 3 *oolean o*"cadena.endsiit(2 )tring 3
@e'uel'e la primera 'e% ue aparece el carcter 2e>presado como entero3 o cadena
pasados como parmetro, pudiendo especificar en un segundo parmetro a partir de
donde *uscar.
int o*"cadena.indexEf2int3 int o*"cadena.inde>Lf2int, int3
int o*"cadena.inde>Lf2)tring3 int o*"cadena.inde>Lf2 )tring, int3
@e'uel'e la -ltima 'e% ue aparece el carcter 2e>presado como entero3 o cadena
pasados como parmetro, pudiendo especificar en un segundo parmetro a partir de
donde *uscar 2*uscar (acia atrs, se entiende3.
int o*"cadena.lastInde>Lf2int3 int o*"cadena.lastInde>Lf2int,int3
int o*"cadena.lastInde>Lf2)tring3 int o*"cadena.lastInde>Lf2)tring, int3
E"emplo0
)tring frX,Estan tan corto el amor y tan largo el ol'ido,H
int > Xfr.inde>Lf2F F3H
)ystem.out.println2Fel primer carcter *lanco se encuentra en la posicin +R >3H
.on'ierte la cadena a min-sculas o may-sculas.
)tring o*"cadena.toLo?erCase23 )tring o*"cadena.to1pper.ase23
)tring o*"cadena.trim230 Elimina espacios al principio y final de la cadena.
)tring o*"cadena.concat2)tring30 de'uel'e la unin de o*"cadena y el parmetro.
@e'uel'e una su*cadena de la cadena actual, empe%ando por el primer ndice indicado
y llegando (asta el segundo ndice 2si lo (u*iera3 o (asta el final de la cadena.
#5
)tring o*"cadena.substring2 int 3 )tring o*"cadena.su*string2 int, int 3
E"emplo0
)tring fra,frX,Estan tan corto el amor y tan largo el ol'ido,H
int > Xfr.inde>Lf2F F3H
fraXfr.su*string20,>3H
)ystem.out.println2FLa primera pala*ra de la frase +R frR + es ,R fra3H
)tring o*"cadena.re!lace2 c(ar, c(ar 30 =eempla%a todos los caracteres iguales al primer
parmetro y los sustituye por el carcter ue pasamos en segundo lugar.
c(arDEo*"cadena.toChar-rray230 .on'ierte la cadena a un 'ector de caracteres.
E"emplo0
)tring frX,Estan tan corto el amor y tan largo el ol'ido,H
fXfr.to.(arArray23H
)ystem.out.println2FLa tercera letra de la frase +R frR + es ,R fD2E3H
3Ftodos estGticos de con,ersin
La clase )tring dispone de 'arios m/todos para transformar 'alores de otros tipos de datos a
cadena. &odos se llaman 'alueLf y son estticos0 )tring )tring.'alueLf2 *oolean 3, )tring
)tring.'alueLf2 int 3)tring )tring.'alueLf2 long 3, )tring )tring.'alueLf2 float 3, )tring
)tring.'alueLf2 dou*le 3, )tring )tring.'alueLf2 L*"ect 3, )tring )tring.'alueLf2 c(arDE 3
E&ercicio 1
.onstruir una clase llamada #rase, ue tiene como atri*uto una frase ingresada por el
usuario, y los metodos get, set, constructores y customer0
largo#rase230 m/todo ue de'uel'e el largo de la frase.
cantidad@eA230 m/todo ue cuenta cuantas letras +a, tiene la frase.
posicionLetra)230 m/todo ue de'uel'e la posicin en ue se encuantra la primera
letra +s, ue aparece en la frase.
pala*ra9asLarga230 de'uel'e la pala*ra mas larga de la frase.
tro%o@eLa#rase230 m/todo ue de'uel'e un tro%o de la frase ue parte en el segundo
espacio en *lanco y termina en el cuarto.
.onstruir una aplicacin ue permita ingresar la informacin necesaria para crear el o*"eto
y mediante un men- 'er ue de'uel'en los m/todos creados.
Creacin de clases colaboradoras
Ltra forma de utili%acin de las clases cola*oradoras es construir las propias, y para esto
uno de*e determinar ue cosas se repiten en muc(as clases, con esta informacin uno
puede construir dic(a clase y utili%arla para en 'e% de colocar los atri*utos ue se repiten
colocar como atri*uto un o*"eto de esta clase. !or e"emplo0 en una clase Alumno podemos
tener como atri*utos, entre otros, nom*re, edad y rut. En la clase &ra*a"ador podemos
#!
tam*i/n tener como atri*utos, entre otros, nom*re, edad y rut. J asi sucesi'amente, por lo
tanto podemos crear la clase !ersona ue tiene los atri*utos nom*re, edad y rut0
class !ersona
C
pri'ate )tring nom*re,rutH
pri'ate int edadH

!ersona2)tring nom*re, )tring rut,int edad3
C
t(is.nom*reXnom*reH
t(is.rutXrutH
t(is.edadXedadH
I
!ersona23
C
I
)tring get8om*re23
C
return2nom*re3H
I
)tring get=ut23
C
return2rut3H
I
int getEdad23
C
return2edad3H
I
'oid set8om*re2)tring nom*re3
C
t(is.nom*reXnom*reH
I
'oid set=ut2)tring rut3
C
t(is.rutXrutH
I
'oid setEdad2int edad3
C
t(is.edadXedadH
I
I
Esta clase se construye una sola 'e% y se podr utili%ar en un sin numero de clase ue
tengan como atri*utos la informacin de una persona. !or e"emplo0 La clase Alumno
pensemos ue adems de nom*re, rut y edad tiene nota. J la clase de*e tener un m/todo
customer ue si la edad es menor de 1U se le de*e sumar a la edad 2. La clase a(ora
uedara0
class Alumno
C
pri'ate !ersona unoH//se declara el objeto del tipo persona el cual tiene en su interior los atributos )edad, nombre y rut*
pri'ate dou*le notaH

Alumno2!ersona uno,dou*le nota3//7sta es una forma de incorporar la informaci0n, esto significa que en la aplicaci0n se crea el
C
t(is.unoXunoH//objeto y se en%a por parametro
t(is.notaXnotaH
I
Alumno2)tring nom*re,)tring rut,int edad,dou*le nota3//7sta es otra forma de hacer lo mismo, pero el objeto se creara en el
C
#6
unoXne; !ersona2nom*re,rut,edad3H// constructor y se en%a la informaci0n necesaria por parmetro desde la aplicacion
t(is.notaXnotaH
I
Alumno23
C
I
!ersona get1no23
C
return2uno3H
I
dou*le get8ota23
C
return2nota3H
I
'oid set1no2!ersona uno3
C
t(is.unoXunoH
I
'oid set8ota2dou*le nota3
C
t(is.notaXnotaH
I
'oid cam*iaEdad223
C
if2uno.getEdad23]1U3//para comparar la edad necesito obtener la edad )get7dad)** pero debo llamarla mediante el objeto )uno*
C
uno.setEdad2uno.getEdad23R23H//de la misma manera para utili,ar el mtodo set, debe hacerse mediante el objeto )uno*
I
I
I
6.omo tra*a"o a(ora desde la aplicacin7 Aeamos como ueda0
class AppAlumno
C
C
)tring nom*re,rutH
int edad, opcionH
dou*le notaH
!ersona au>H
)ystem.out.println2FIngrese nom*re del alumnoF3H
nom*reXLeer.dato23H
)ystem.out.println2FIngrese rut del alumnoF3H
rutXLeer.dato23H
)ystem.out.println2FIngrese edad del alumnoF3H
!ersona unoXne; !ersona2nom*re,rut,edad3H
)ystem.out.println2FIngrese nota del alumnoF3H
notaXLeer.dato@ou*le23H
///e creara un primer objeto de esta forma, utili,ando el objeto .ersona creado aqui
Alumno dosXne; Alumno2uno,nota3H
///e crea otro objeto con los mismos datos pero de forma distinta porque el objeto .ersona se creara en la clase .lano
Alumno tresXne; Alumno2nom*re,rut,edad,nota3H

doC
)ystem.out.println2FKue desea 'er, digite opcionF3H
)ystem.out.println2F10 Aer nom*re del o*"eto1F3H
)ystem.out.println2F20 Aer nom*re del o*"eto2F3H
)ystem.out.println2FT0 Aer edad del o*"eto1F3H
)ystem.out.println2FV0 Aer edad del o*"eto1F3H
)ystem.out.println2FM0 modificar el o*"eto1 y 'erF3H
)ystem.out.println2FU0 salirF3H
#-
s;itc(2opcion3
C
case 10
au>Xdos.get1no23H//para mostrar necesito de%ol%er el objeto .ersona con el objeto dos y lo recibo en el objeto au1
nom*reXau>.get8om*re23H//ahora con el objeto persona )au1* llamo al nombre
)ystem.out.println2FEl nom*re del o*"eto1 es0 FRnom*re3H
*rea?H
case 20
au>Xtres.get1no23H
nom*reXau>.get8om*re23H
)ystem.out.println2FEl nom*re del o*"eto2 es0 FRnom*re3H
*rea?H
case T0
edadX2dos.get1no233.getEdad23H//tambien se puede hacer el proceso directo
)ystem.out.println2Fla edad del o*"eto1 es0 FRedad3H
*rea?H
case V0
edadX2tres.get1no233.getEdad23H
)ystem.out.println2FLa edad del o*"eto2 es0 FRedad3H
*rea?H
case M0
edadX2dos.get1no233.getEdad23H
)ystem.out.println2FLa edad del o*"eto1 es0 FRedad3H
dos.cam*iaEdad223H
edadX2dos.get1no233.getEdad23H
)ystem.out.println2FLa nue'a edad del o*"eto1 es0 FRedad3H
*rea?H
case U0
*rea?H
I
I;(ile2opcionGXU3H
I
I
E&ercicio 1
1tilice esta misma clase para la clase &ra*a"ador, ya construida y remplace los atri*utos y
'ea como se comporta.
Estos apuntes de programacin, solo pretenden ser una gua adicional a la materia 'ista en
el curso, y es producto de la constante solicitud de los alumnos por contar con un material
escrito, para poder repasar o estudiar o a'an%ar ms alla.
=ecuerden ue cuando un alumno estudia y (ace muuuuuuc(os e"ercicios le 'a *ien en
controles y prue*as, pero si no lo (ace le 'a mal 26Ku/ raro7, 'erdad3.
#e*rero 2010.

Bibilia de Don Juan Corvalan

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Bibilia de Don Juan Corvalan

Diunggah oleh

Hak Cipta:

Format Tersedia

Escuela de informtica y telecomunicaciones

Anda mungkin juga menyukai