Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Programación Orientada A Objetos Programa Java PDF
Programación Orientada A Objetos Programa Java PDF
Programa desarrollado
Programa de la asignatura:
Programación Orientada a Objetos I
Índice
a. Ficha de identificación
b. Descripción
El ser humano siempre ha visto el mundo a través de objetos, por ejemplo, al observar
algo simple como un zapato, nuestra mente lo asimila como un objeto, el cual tiene
características (atributos), como lo son: color, talla, tipo de suela, estilo, etcétera; también
tiene acciones que pueden ser aplicadas sobre él (métodos) como: bolearlo, limpiarlo,
abrocharlo, entre otros más. Mientras nos imaginamos el objeto zapato, éste varía
dependiendo de sus características y el escenario, es decir, un zapato puede ser una
zapatilla, bota, tenis o huarache; sin embargo, contiene las mismas acciones ya
mencionadas. Considerando esto, se puede ver el alcance y las ventajas de la
programación orientada a objetos (POO) para la portabilidad y reutilización de código,
evitando programar varias veces lo mismo. Tomando el ejemplo mencionado con
anterioridad, solamente es necesario programar un método bolear-zapato, en lugar de
bolear-zapatilla, bolear-bota, bolear-tenis y bolear-huarache. El desarrollo de programas
orientados a objetos implica la creación de objetos del mundo real, y la construcción de
programas basados en el modelo orientado a objetos.
c. Fundamentación de la asignatura
Los fundamentos que justifican la asignatura son de carácter teórico-práctico, dado que la
estructura de las unidades está diseñada de una manera donde se combina la teoría y la
práctica. En la unidad 1, se cubren los conceptos de la programación orientada a objetos
y su diferencia con la programación estructurada, así como las características del
lenguaje JAVA y la organización de un programa en JAVA, de modo tal que el estudiante
comprenda primero los conceptos, después identifique la sintaxis (secuencia correcta de
los elementos de un lenguaje de programación) que JAVA ofrece para implementar dichos
conceptos y después logre aplicarlos en un programa. La unidad 2 muestra de la misma
manera que la anterior una combinación de la teoría y la práctica considerando las
generalidades de los métodos, los que devuelven valor y los que no devuelven valor, así
como las estructuras de control selectivas y cíclicas, donde se incluyen conceptos y
ejemplificación práctica de los temas que se abordan. En la unidad 3 se abarcan temas
como la herencia, el polimorfismo y las excepciones se desarrolla igual que las anteriores
con una combinación de teoría y ejemplificación práctica de todos los temas. Por último la
unidad 4 contiene temas de arreglos unidimensionales y bidimensionales donde se
incluye los conceptos de estos temas, y se enfoca más hacia la práctica de estos temas.
d. Propósito
e. Competencia(s) a desarrollar
Competencia general:
Construir programas modulares bajo el paradigma orientado a objetos para satisfacer
necesidades en el procesamiento de información mediante su análisis y su codificación en
lenguaje JAVA.
Competencias específicas:
Desarrollar un programa básico para la solución de problemas matemáticos
simples tomando en cuenta el entorno, características y especificaciones de los
programas JAVA a través de dicho lenguaje.
Desarrollar programas modulares para solucionar problemas diversos, mediante la
aplicación de los diferentes tipos de variables, métodos, y estructuras de control en
lenguaje JAVA.
Desarrollar programas modulares para solucionar problemas diversos, aplicando la
herencia, el polimorfismo y el manejo de excepciones mediante la sintaxis que
JAVA ofrece para su implementación.
Construir programas para el manejo de datos del mismo tipo (carácter, cadena,
entero o decimal) a través del uso de arreglos aplicados en problemas
matemáticos simples.
f. Temario
En este apartado se desglosará el contenido de la asignatura a detalle.
3.1 Herencia
3.1.1 Subclases y superclases
3.1.2 Jerarquía de la herencia
3.1.3 Clases y métodos abstractos
3.2 Polimorfismo
3.2.1 Clases y métodos finales
3.2.2 Interfaces
3.2.3 Sobrecarga de métodos
3.2.4 Sobrecarga de operadores
3.3 Excepciones
3.3.1 Sentencia Try – catch
3.3.2 Tipos de errores
3.3.3 Jerarquía de las excepciones
Unidad 4. Arreglos
4.1 Arreglos unidimensionales
4.1.1 Declaración
4.1.2 Recorrido
4.1.3 Operaciones
4.2 Arreglos multidimensionales
4.2.1 Declaración
4.2.2 Recorrido
4.2.3 Operaciones
g. Metodología de trabajo
h. Evaluación
ESQUEMA DE EVALUACIÓN
Interacciones individuales y
Evaluación 10%
colaborativas
continua
Tareas 30%
Evidencias 40%
E-portafolio. 50%
Autorreflexiones 10%
Examen 10%
CALIFICACIÓN 100%
FINAL
Cabe señalar que para aprobar la asignatura, se debe de obtener la calificación mínima
indicada por ESAD.
Los trabajos que se tomarán en cuenta como evidencia del aprendizaje son:
Unidad 1: Programa en JAVA. Dados dos números por el usuario, reste y multiplique
mostrando el resultado en pantalla.
Unidad 4: Programar una aplicación que muestre en un menú todos los programas vistos
en el curso.
i. Fuentes de consulta
Bibliografía básica
Bibliografía complementaria
Presentación de la unidad
Propósitos de la unidad
Competencia específica
Actividad 1. Presentación
Hoy en día podemos entender que en la vida diaria estamos rodeados de objetos y que
estos objetos coexisten con nosotros, pero ¿Qué es un Objeto?
Podemos describir y nombrar los objetos para entender cuáles son las diferencias entre
ellos, por ejemplo si vas a un supermercado, encontramos “carritos de super” y canastillas
de mercado, ambos son objetos con propiedades o atributos en común, espacio para
cargar o transportar artículos pero a la vez tienen diferencias, la canastilla de mercado
necesitamos cargarla y al “carrito de super” no, es decir cada uno es para un fin
específico y práctico.
De tal modo, podemos definir a un objeto como una entidad compleja con propiedades
(datos, atributos) y comportamiento (funcionalidad, métodos). Con todas éstas
características es conveniente afirmar que todo lo que nos rodea se puede representar y
que cada uno de estos objetos posee una interfaz que especifica cómo éstos pueden
interactuar con otros, dichos objetos tienen instrucciones propias (Joyanes, 2001).
1.1.1. Abstracción
“La propiedad de los objetos que consiste en tener en cuenta sólo los aspectos más
importantes desde un punto de vista determinado y no tener en cuenta los restantes
aspectos que no son significativos. Durante el proceso de abstracción es cuando se decide
qué características y comportamiento debe tener el modelo. Un medio de reducir la
complejidad es la abstracción. Las características y los procesos se reducen a las
propiedades esenciales, dejando de lado los demás detalles no sustanciales. De este modo,
las características complejas se hacen más manejables” (Joyanes, 2001: 5).
La abstracción como tal nos sirva para poder pasar del plano material al plano mental.
Ahora bien, ¿cómo se relaciona la abstracción con la POO? Imaginemos que tenemos un
grupo de tornillos y de dicho grupo un tornillo se podría manejar con un desarmador
específico, pero también con cualquier otro desarmador aunque no sea nuestro, lo mismo
pasa en un sistema software, los módulos son independientes, pero a la vez funcionan
como un gran modulo del software, es decir podemos partir un gran software para poder
hacerlo en módulos, esto hará más fácil la identificación de sus características básicas.
1.1.2. Polimorfismo
“La propiedad de polimorfismo es aquella en que una operación tiene el mismo nombre en
diferentes clases, pero se ejecuta de diferentes formas en cada clase”. (Joyanes, 2001:
6). Dicho de otro modo es la capacidad que tiene una clase para adaptarse a diferentes
usos sin necesidad de modificarla. Así, por ejemplo, la operación copiar puede darse en
diferentes clases: copiar un libro, copiar un archivo, copiar una actitud, copiar un
comportamiento, copiar en un examen, etc. Siempre se ejecuta una operación distinta
pero con el mismo nombre “copiar”. Por tanto:
1.1.3. Encapsulación
Si bien externamente los objetos pueden parecer iguales, internamente pueden ser muy
distintos. Por ejemplo, si sabes manejar un reproductor de DVD, puedes manejar
cualquier otro reproductor como CD y BLUE RAY, esto es encapsular, los dos
reproductores pueden ser parecidos por fuera, pero por dentro funcionan de diferente
forma.
1.1.4. Herencia
Las características de un objeto pueden ser heredadas del objeto que está en el nivel
superior, por ejemplo novillo tiene orejas y cola y su pelo es negro como el de un toro
normal pero su cornamenta es más delgada y más fina, el toro y el novillo son parecidos
pero no son iguales.
En programación la herencia se aplica sobre las clases, y tenemos clases padre, de las
cuales de despliegan las clases hijo, que heredará las características del padre y pueden
tener otras características más.
Hasta este punto hemos visto solo los conceptos generales que dan cabida a la POO,
más adelante en el curso veremos cómo estos conceptos se implementan ya en la
programación.
La POO tiene sin duda muchas de sus bases en la programación estructurada, la principal
diferencia entre estos dos paradigmas radica en que, en la programación estructurada la
atención principal del programa (y del programador) está en la secuencia de las
instrucciones, mientras que en la POO la atención principal está en las partes (objetos)
que la conforman, cómo interactúan y las operaciones que se pueden hacer sobre los
mencionados objetos. Para tener un panorama más claro sobre lo explicado se sugiere al
lector imaginar un archivo electrónico cualquiera. En términos de la POO las acciones que
se aplican sobre este objeto pueden ser imprimir, borrar, renombrar, escribir más letras,
entre otros. Aunque se piense que si se compara el código generado para las mismas
A modo de lista, se presentan los siguientes puntos como principales diferencias entre
ambos paradigmas:
La POO se considera la evolución de la programación estructurada en cuanto a la
atención de problemas complejos y cambiantes.
La POO se basa en lenguajes que soportan descripción y escritura de tipos de
dato complejos (no sólo primitivos) y las operaciones que se pueden efectuar
sobre ellos: la clase.
La POO incorpora niveles profundos de abstracción que permiten utilizar (entender
y aplicar) conceptos como el polimorfismo, la herencia, la sobrecarga, entre otros.
Los creadores de la programación estructurada encontraron solución al problema
presentado por ésta (no dar el ancho ante la complejidad de los problemas a resolver) y
fue el seguimiento de rigurosos métodos de trabajo al utilizar la programación
estructurada, pero pocos fueron quienes aceptaron trabajar bajo tal presión.
Durante esta actividad reflexionarás acerca de las diferencias existentes entre análisis,
programación estructurada y programación orientada a objetos tomando en cuenta los
temas vistos y los comentarios de los compañeros(as) del grupo.
Realiza lo siguiente:
Hasta el momento en que se escribe el presente documento hay varias versiones que
describen el origen de Java como proyecto y como lenguaje de programación que van
desde situar sus orígenes entre finales de la década de los ochentas y 1990 (Zukowski,
1997) hasta mediados de la década de los noventas. De manera general se describe
como un lenguaje de programación que fue pensado para desarrollar software que se
utilizará dentro de la electrónica de consumo (refrigeradores, lavadoras, entre otros)
desarrollado por el Green Team de Sun Microsystems liderado por Bill Joy, y aunque la
idea original de usarlo en electrónicos fracasó, fue rescatado tiempo después para ser
usado como lenguaje de propósito general y esta idea le dio la principal característica que
lo hizo popular y lo sigue manteniendo en el gusto generalizado; su capacidad
multiplataforma. Además con API’s que dan soporte a acceso a base de datos, objetos
remotos y modelos de componentes de objetos, internacionalización, impresión y
reporteo, encriptación, procesamiento de señales digitales y muchas otras tecnologías y
capacidades lo posicionan tomando gran parte de la tajada sobre los lenguajes de
programación más utilizados.
En una de las primeras publicaciones que hacen referencia a Java (Zukowski, 1997), Sun
lo describe como un sencillo, orientado a objetos, distribuido, interpretado, robusto,
seguro, de arquitectura neutral, portable, de alto rendimiento, multihilo, y dinámico
lenguaje.
Sus creadores reconocen que estas palabras pueden llegar a ser pretenciosas, pero el
hecho es que, en su totalidad, se describe acertadamente el lenguaje. Para tener una
mejor comprensión de la descripción hecha sobre Java, se revisará a las características
del lenguaje detrás de cada palabra.
Cuando se trabaja con el paradigma orientado a objetos, una clase es una colección de
datos y tiene además métodos que operan sobre esos datos. En conjunto, los datos y
métodos describen el estado y el comportamiento de un objeto.
Java cuenta con un amplio conjunto de clases organizadas en paquetes, que se pueden
utilizar al programar. Proporciona paquetes de clases para la interfaz gráfica de usuario
(java.awt), clases que se encargan de la entrada y salida (java.io), funcionalidad de
soporte de red (java.net), entre muchos otros paquetes.
Desde la concepción inicial del diseño de Java se pensó en hacer de este un lenguaje
totalmente orientado a objetos desde la base, a diferencia de otros lenguajes que fueron
adoptando los lineamientos de este paradigma en sus características, como por ejemplo
C++. La mayoría de los elementos disponibles en Java con objetos, con excepción de los
tipos primitivos y los tipos booleanos. Las cadenas o arrays son en realidad objetos en
java. Una clase es la unidad básica de compilación y ejecución en Java, todos los
programas de Java con clases.
Se pueden, por ejemplo, ejecutar applets desde cualquier navegador de cualquier sistema
operativo que cuente con una JVM y más allá todavía, hacer sistemas autónomos que se
ejecuten directamente sobre el sistema operativo. Esto es particularmente importante
cuando se trabajará con aplicaciones distribuidas por internet o cualquier otro medio de
distribución donde los usuarios no pueden (deben) tener un cierto sistema operativo
funcionando en la computadora donde se ejecutará dicha aplicación.
En las aplicaciones que se desarrollan hoy en día, muy probablemente se necesite tener
la misma versión ejecutándose en un ambiente de trabajo con UNIX, Windows o Mac. Y
más aún, con las diferentes versiones de procesadores y dispositivos (celulares, celulares
inteligentes, consolas de video juegos, entre muchos otros) soportados por estos
sistemas, las posibilidades se pueden volver interminables y la dificultad para mantener
una versión de la aplicación para cada uno de ellos crece de igual manera, interminable.
Robusto. Java fue diseñado para ser un lenguaje de programación que genere
aplicaciones robustas. Java no elimina la necesidad del aseguramiento de calidad en el
software; de hecho es muy posible y probable tener errores al programar en Java. No
elimina tampoco la mayoría de los errores que se comenten al utilizar cualquier lenguaje
de programación.
Sin embargo al ser fuertemente tipado se asegura que cada variable o método que se
utilice corresponda en realidad a lo que el programador quiso utilizar y no que se escapen
errores en conversión de tipos de dato, por ejemplo. Java requiere declaración explicita de
métodos, cosa que no se permite en otros lenguajes, como en C. Java ha sido pensado
en la fiabilidad, eliminando la mayoría (o todas) las posibles partes de otros lenguajes de
programación propensas a errores, por ejemplo elimina los punteros y soporta el manejo
de excepciones en tiempo de ejecución para proporcionar robustez a la programación.
Java utiliza recolección de basura en tiempo de ejecución en vez de liberación explícita de
memoria. En lenguajes como C++ es necesario borrar o liberar memoria una vez que el
programa ha terminado (Joyanes y Fernández, 2001).
Los programadores de Java no tienen permitido cierto tipo de acciones que se consideran
altamente vulnerables o que el típico caso de ataque contra un usuario común, por
ejemplo el acceso a memoria, desbordamiento de arreglos entre muchos otros.
Otra capa de seguridad dentro de Java es el modelo sandbox que hace una ejecución
controlada de cualquier bytecode que llega a la JVM, por ejemplo si se lograr evadir la
regla del código no malicioso al momento de compilar, este modelo en su ejecución
controlada evitaría que las repercusiones lleguen al mundo real.
Por otro lado, otra posible solución al aspecto de seguridad en Java es que se añade una
firma digital al código de Java, el origen del software puede establecerse con esta firma y
utilizando criptografía se oculta esta firma para que sea inaccesible e inmodificable por
cualquier persona. Si hay confianza en una persona específica de alguna organización,
entonces el código puede ser firmado digitalmente por dicha persona, dándonos la
seguridad que el resultado que recibimos sea de quien debe ser y no haya introducción de
código por terceras personas ajenas a él.
Por supuesto la seguridad no puede entenderse ni manejar como una cosa que es
totalmente blanca o totalmente negra, deben descubrirse los matices que pueda presentar
y verificar todas las posibles vertientes que puedan tomar los matices, así nos
aseguraremos que todo está controlado. Ningún programa puede dar al 100% la garantía
de la ausencia de errores, tampoco un ambiente de compilación o interpretación puede
dar esta garantía. Java no se centra en la corrección de seguridad, se basa en la
anticipación de los posibles errores que se puedan presentar.
Alto Rendimiento. Java es un lenguaje interpretado, por eso no será igual de veloz en la
ejecución como un lenguaje compilado como C. En versiones tempranas de Java está
aún decenas de veces más abajo que la velocidad de ejecución que proporciona C. Sin
embargo con el pasar del tiempo este aspecto ha ido mejorando sobre la base del
compilador JIT (just in time) que permite programas en Java de plataforma independiente
se ejecuten casi tan rápido como los lenguajes convencionales compilados.
Multihilo. Es fácil imaginar cómo funciona una aplicación que hace múltiples cosas a la
vez, por ejemplo en un navegador web, donde, se hace la descarga al mismo tiempo del
texto, imágenes, videos y demás componentes de la página que visitamos, pero esta
descarga se hace por separado, donde una función específica se hace cargo de
descargar las imágenes, otra el texto y así con cada uno de los compontes. Obviamente
lo hacen al mismo tiempo, por esto se dice que es multihilo. Java es un lenguaje multihilo
ya que soporta la ejecución de múltiples tareas al mismo tiempo y cada uno de esos hilos
puede soportar la ejecución de una tarea específica diferente. Un beneficio importante de
esta característica multihilo es el aporte que da a las aplicaciones basadas precisamente
en esto, ya que como se mencionó, incrementa el rendimiento de la aplicación, sobre todo
en aplicaciones basadas en interfaces gráficas de usuario.
¿Qué es la JVM?
Una Máquina Virtual de Java (JVM), es un software de proceso nativo, es decir, está
desarrollada para una plataforma específica que es capaz de interpretar y ejecutar un
programa o aplicación escrito en un código binario (el ya mencionado bytecode) que se
genera a partir del compilador de Java.
Haciendo una apología sobre la base de la seguridad la JVM impone formatos fuertes y
limitaciones estructurales en el bytecode (por ejemplo los apuntadores a memoria, que ya
se han mencionado en apartados anteriores). Sin embargo, cualquier lenguaje formal, con
la funcionalidad que se pueda expresar en términos de un archivo de bytecode válido,
puede ser organizado, interpretado y ejecutado por la JVM. Atraídos por la gran
Cuando se está inmerso dentro del mundo de desarrollo de software en Java, hay varias
opciones sobre la manera en que se pueden generar aplicaciones. Por ejemplo podemos
utilizar un editor de texto cualquiera (notepad) para poder capturar el código fuente y
guardarlo en el disco duro con el formato y la extensión correctos, para después en una
segunda parte, compilar dicho código fuente y que nos arroje el bytecode a través de la
línea de comandos haciendo una invocación al compilador de Java. Obviamente se
deberá tener configurado en la estación de trabajo la manera en que ésta reconozca qué
estamos haciendo y de dónde lo estamos llamando.
Quien desarrolla sólo deberá preocuparse por los datos que involucren a su
aplicación, la manera de cómo obtenerlos, procesarlo y tal vez almacenarlos,
preocuparse por entender las reglas del negocio al cual pretende generarle dicha
aplicación, cómo y en qué parte afectan estas reglas para su aplicación y sus datos,
la mejor manera de explotar el conocimiento que genere su aplicación y no estar
preocupado por configurar variables de entorno, preocupado por configurar
conexiones a bases de datos ni aspectos específicos o variables complejas de los
servidores de aplicaciones web, entre muchas otras cosas inherentes al sistema, no
a la aplicación.
Las herramientas antes mencionadas, cuando se trabajan en conjunto como una sola
unidad operativa, se le conoce como Entorno Integrado de Desarrollo (EID) o IDE por sus
siglas en inglés (Integrated Development Environment), que podemos entenderlo como un
programa de tipo informático que conjunta al mismo tiempo varias herramientas útiles
para la programación de aplicaciones. El IDE puede estar enfocado a un lenguaje
específico o soportar una colección de ellos, como es usual en los IDE’s modernos; por
ejemplo el IDE más popular de Microsoft es el Visual Studio en su versión 2010 (al
momento de escribir este documento) y tiene soporte nativo para una variedad muy
amplia de lenguajes soportados, e inclusive que se pueden mezclar. Cuando
transportamos este concepto del IDE a Java, existen de igual manera varios de donde se
puede hacer una elección, por ejemplo:
• Eclipse
• Borland JBuilder
• Sun Java Studio Creator
• NetBeans
• IBM WebSphere Studio Site Developer for Java
• Dreamweaver
• WebLogic Workshop
• Oracle JDeveloper
• IntelliJ Idea
• JCreator
Nota: Todas las marcas o nombres de productos son propiedad de sus respectivos
dueños y sólo se usan a manera de ilustrar el ejemplo expuesto.
Un editor de texto, que es el programa o parte del IDE que nos permitirá crear,
abrir o modificar el archivo contenedor del código fuente del lenguaje con el que
estemos trabajando. Puede proporcionarnos muchas ventajas sobre un editor de
texto separado del IDE, ya que por lo general cuentan con un resaltado de sintaxis
sobre las partes que conforman el código fuente de la aplicación que se esté
construyendo.
Un compilador, que es el programa o parte del IDE que nos permitirá traducir el
código fuente escrito dentro del editor a lenguaje máquina (bytecode en el caso de
Java). De tal manera que el programador pueda diseñar y programar una
aplicación utilizando palabras, frases o conceptos muy cercanos al lenguaje que
utiliza normalmente, y el compilador se encargará de traducir estas sentencias en
instrucciones comprensibles por el procesador de la computadora.
Un intérprete, que es el programa o parte del IDE que nos permitirá hacer la
“interpretación” del código compilado (como en el caso de Java), en donde se
toma como entrada el bytecode y el resultado es la ejecución de las instrucciones
de lenguaje máquina o código objeto contenidas en esta estructura de clases. El
compilador e intérprete pueden trabajar en conjunto como se explica en este
apartado o ser procesos independientes para la ejecución de un programa.
Un depurador, que es el programa o parte del IDE que nos permitirá probar y
localizar errores dentro del código de la aplicación (mayormente de tipo lógico o de
omisión) haciendo una traza de la ejecución completa del código y señalando
dónde será un posible error del código o vulnerabilidad no considerada.
Un constructor de interfaces gráficas, que es la parte del IDE que nos facilita una
serie de componentes nativos del lenguaje con el que trabajamos (swing en Java)
para poder ofrecer al usuario un ambiente amigable de tipo visual, en pocas
palabras nos permite crear interfaces gráficas de usuario y complementarlas con el
código fuente de nuestra aplicación.
Opcionalmente la posibilidad de trabajar conectado a un servidor de control de
versiones, que nos permitirá llevar un control preciso de cada versión de cada
archivo que comprenda nuestra aplicación, particularmente útil cuando se trabaja
con aplicaciones de tipo empresarial que conllevan, inclusive, miles de archivos de
código fuente y al estar trabajando en grupo se vuelve indispensable esta
funcionalidad que ofrece el IDE.
Otra posible opción de configuración interesante sobre cada proyecto que se maneja en el
IDE es de qué parte toma las clases base (independientes a las que proporciona Java) y
cómo será la salida de la aplicación (jar, jar compimido, entre otros).
La manera de identificar qué tipo de dato utilizar es analizar qué datos almacenará esa
variable para definir su tipo de datos en base al rango de valores y descripción dados en
la tabla anterior.
Para utilizar un dato debemos colocar al inicio el tipo de dato que queremos, seguido el
nombre que tendrá ese dato y un punto y coma si no se quiere dar un valor inicial, pero si
se va a dar un valor colocamos una asignación con un igual y el valor.
Ejemplo de utilización
public class DataTypes
{
public static void main(String[] args)
{
double f = 55E100;
char charValue= '4'; // char '4' no es el entero 4
2. Identifica el tipo de datos que se requieren para programar como variable cada
dato brindado.
Tabla 1
Datos de #_pisos #_cuartos #_ventanas #_baños Fondo
una casa
Tipo
Datos de #_puertas #_cilindros #_hp colorCarroceria #_placas
un auto
Tipo
Datos de #_folio total nombreCliente nombreEmpresa Iva
una
factura
Tipo
Datos de punto material Tacón color #_estilo
un
zapato
Tipo
Datos de Marca procesador Memoria pantalla discoDuro
una
computa
dora
Tipo
Pueden tener notación prefija o posfija, que se defina en la posición que se coloquen los
operadores respecto a sus operandos, así en la notación prefija los operadores irán a la
izquierda del operando (++a) y en la notación posfija los operadores irán a la derecha de
los operandos (a++).
Existen varios tipos de operadores que se puede utilizar de distinta manera y arrojando
resultados diferentes para la realización de operaciones, se listan a continuación.
Operadores aritméticos
Operadores lógicos
Operador Descripción
== Igual (comparación de igualdad)
> Mayor que
< Menor que
&& Conjunción lógica (and)
!= Distinto
>= Mayor o igual que
<= Menor o igual que
|| Disyunción lógica (or)
Utilización de operadores lógicos
Operadores de asignación
int contador = 0;
Iniciando la variable contador con un valor de 0.
Además de las facilidades ya descritas que nos proporciona el lenguaje Java, proporciona
una forma abreviada de representar este tipo de operadores, con la finalidad de agilizar la
escritura para los programadores. Se describen en la siguiente tabla:
Operadores de bit
La función específica de este tipo de operadores es desplazar los bits del operando
ubicado a la izquierda de la expresión el número de veces que indique el operador de la
derecha. La dirección del operador indica hacia donde correrán los bits. La siguiente
sentencia nos da a entender bien el concepto que se trata de implementar, al desplazar
los bits del entero 25 a la derecha de su posición:
25 >> 2
Precedencia de operadores
Java asigna (como se hace en las operaciones matemáticas normales) una importancia
muy alta a la precedencia de los operadores. En la siguiente tabla se lista esta
precedencia y entre más alta sea su posición, más importancia tendrá:
Operadores Representación
Operadores posfijos [], (), a++, a--
Operadores unario ++a, --a, +a, -a, ~, !
Creación o conversión new(tipo) a
Multiplicación *, /, %
Suma +, -
Desplazamiento <<
Comparación ==
Igualdad ==, !=
AND a nivel de bit &
OR a nivel de bit ^
XOR a nivel de bit |
AND lógico &&
OR lógico ||
Condicional ?:
Asignación =, +=, -=, *=, /=, &=, ^=, |=, <<===
Actividad 5. Operadores
Durante esta actividad realizarás un ejercicio donde recuperes lo que has aprendido
acerca de los operadores soportados por JAVA. Realiza lo siguiente:
2. Completa los datos que se solicitan en las columnas vacías. Para ello, identifica
los operadores encontrados en cada operación, su tipo de operador y el resultado
de dicha operación.
Tabla 2
# Operadores Tipo de
Operación Resultado
encontrados operadores
1 (3 + (2 *3) -12) / 3
P: Verdadero
2 Q: Falso
PyQ
3 10> 5 >6
4 (((200 +305)/56)*30)<12
P: 3+9<10
5 Q:30 -64 > - 40
PoQ
Pero si en el resultado es importante tomar en cuenta también los decimales para tener
un resultado más preciso debemos convertir el entero a flotante, eso se realiza de la
siguiente manera.
float c= (float) di/dv;
Colocando el tipo de dato al que se convertirá entre paréntesis, ahora nuestro resultado
mostrará los decimales que necesitamos.
Si ahora se quiere usar estos objetos, se tendrá que hacer un cambio entre resultados
que los tienes como array[i], que son Object, y no puedes llamar a métodos específicos de
las clases A, B y C. La forma de recuperar las clases originales es con un cast, que al
igual que el ejemplo anterior debes colocar el tipo al que quieres convertir entre parénesis
antes del dato que se convertirá, entonces se pone el tipo A delante, entre paréntesis.
((A)array[0]).metodoDeA();
Java guarda una enorme semejanza con C/C++ por lo que no es difícil poder entender ni
interpretar su código cuando se está familiarizado con estos lenguajes. De igual manera
como Java sigue el paradigma de la Programación Orientada a Objetos (POO) en código
del lenguaje se construye a partir de la escritura de clases.
Durante esta unidad se sugiere que se realicen todos los ejemplos en el entorno de
desarrollo para que lo tengas instalado y funcional desde esta primera unidad, ya que se
estará utilizando a lo largo de toda la materia, además se sugiere que escribas, compiles
y ejecutes los ejemplos de programas que se desarrollaron en esta unidad, para que se
comprenda mejor lo visto.
Todo parte de una clase. Partiendo desde la concepción más simple de un programa en
Java, este se puede escribir a partir de una sola clase y conforme la complejidad de la
aplicación vaya en aumento, muy probablemente (de hecho lo es) el número de clases va
a ir en aumento, se podría entender como una correlación directa. Por definición cada
clase necesita un punto de entrada por donde comenzará la ejecución del programa, y la
clase escrita debe contenerlo como el programa, rutina o método principal: main() y dentro
de este método contiene las llamadas a todas las subrutinas o demás partes de la clase o
incluso de la aplicación en general.
Una estructura simple pero funcional de un programa en Java sería como sigue:
public class inicio{
public static void main(String[] args){
Primer_sentencia;
Sentecia_siguiente;
Otra_sentencia;
// …
Sentencia_final;
} //cierre del método main
} // cierre de la clase
Al hacer la implementación del ejemplo anterior a algo un poco más real y palpable se
sugiere como primer acercamiento un programa sencillo escrito en lenguaje Java que
muestre en pantalla un mensaje de bienvenida a la programación en Java.
/**
* La clase bienvenida construye un programa que
* muestra un mensaje en pantalla
*/
public class bienvenida {
public static void main(String[] args) {
System.out.println("Hola, ");
System.out.println("bienvenido (a)");
// Este es un comentario escrito en una sola línea y para hacer comentarios breves y
concisos.
Como se puede observar el comentario comienza con un par de caracteres del tipo “/” y
nótese que no se deja espacio alguna entre ellos, después de esto se puede comenzar a
escribir el cuerpo del comentario de una sola línea. Cuando hay la necesidad de hacer
observaciones muy amplias y que una línea no nos dé el espacio suficiente se sugiere
utilizar comentarios de varias líneas, por ejemplo;
/*
Este es un comentario muy amplio y se puede hacer con la utilización de varias líneas sin
perder la continuidad de la idea e indicándole al compilador que ignore por completo todas
las líneas que lo comprenden.
*/
De igual forma que en los comentarios de una sola línea, los comentarios multilínea
comienzan con el par de caracteres “/*” y terminan con el par de caracteres “*/”.
Además en Java existe un tercer tipo de comentario que se le conoce como “comentario
de documentación” y este tipo la función que tienes es que le indica al programa
generador de documentación que lo incluya a él e ignore de los demás, por ejemplo:
/** Comentario de documentación del programa */
Identificadores
if ( condición ){
Sentencia1;
}
else
{
Sentencia2;
}
Espaciado (Spacing): Colocar una sentencia por línea, y usar de dos a cuatros
líneas vacías entre sentencias para hacer el código legible. El número de espacios
puede depender mucho del estándar que se use.
Comentarios (Comments): Utilizar comentarios para explicar los segmentos de
código que no son obvios. Utilizar // para comentar una sola línea; para comentar
extensiones más grandes de información encerrar entre los símbolos delimitadores
/* */. Utilizar los símbolos /** */ para documentar los comentarios para proveer
una entrada al javadoc y generar un HTML con el código.
//Un comentario de una sola línea
/*Comentarios que pueden abarcas más de
una línea*/
/**Un cometario para propósitos de documentación
*@see otra clase para más información
*/
Nota: la etiqueta @see es especial para javadoc para darle un efecto de
“también ver” a un link que referencia una clase o un método.
Se entiende como palabra reservada a un tipo especial de identificadores que sólo puede
emplear el lenguaje Java, es decir su uso es exclusivo del lenguaje y el programador no
puede hacer uso de ellas para nombrar métodos, clases, variables o cualquier otra parte
del código fuente, se presentan estas palabras reservadas en la siguiente tabla:
Aunque la definición del lenguaje Java toma en cuenta todas estas palabras, en su
implementación no se toman en cuenta todas, las que están marcadas con un asterisco
aún no tienen utilización.
Ejemplo Uso
package javaapplication1; Paquete
import javax.swing.*; import si se requiere
Esto significa que se mapea la clase hacia un objeto. Allan Kay (citado en Zukowski,
1997) describió las 5 principales características de Smalltalk, uno de los primeros
lenguajes orientados a objetos y uno de los lenguajes en los cuales está basado Java:
Constructores
Un constructor es un método especial en Java empleado para inicializar valores en
instancias de objetos, a través de este tipo de métodos es posible generar diversos tipos
de instancias para la clase en cuestión; la principal característica de este tipo de métodos
es que llevan el mismo nombre de la clase.
Si la clase se llama empleado su declaración sería:
public class empleado { …… }
El constructor debería quedar como sigue
public empleado(){}
Autoevaluación
Para reforzar los conocimientos relacionados con los temas que se abordaron en esta
primera unidad del curso, es necesario que resuelvas la autoevaluación de la unidad.
Recuerda que es muy importante leer cuidadosamente los planteamientos indicados y
elegir la opción adecuada para cada uno.
Autorreflexiones
Cierre de la unidad
Has concluido la primera unidad del curso. A lo largo de ésta te has introducido a la
programación orientada a objetos y sus principales características como abstracción,
polimorfismo, encapsulación y herencia; también has estudiado la diferencia entre la
orientación a objetos y la programación estructurada. Posteriormente te involucraste en
las características del lenguaje JAVA, sus tipos de datos soportados, tipos de operadores
y conversión de tipos de datos. Estos temas han servido para que vayas conociendo el
ambiente de desarrollo de programas computacionales.
Es aconsejable que revises nuevamente la unidad en caso de que los temas que se
acaban de mencionar no te sean familiares o no los recuerdes, de no ser este tu caso, ya
estás preparado(a) para seguir con la unidad dos, en donde continuarás con la revisión de
los métodos y las estructuras de control. Todo ello con el fin de obtener el conocimiento
necesario para comenzar a realizar pequeños programas computacionales al final de la
cuarta y última unidad del curso de Programación Orientada a Objetos I.
Es importante que instales un IDE en tu computadora personal para que pases todos los
ejemplos de código y veas cómo funcionan, de esta manera podrás analizar el
funcionamiento de los códigos presentados.
*Nota: se recomienda que instales NetBeans 7.0, como IDE, por su facilidad de uso, este
puede ser descargado gratuitamente de la siguiente liga:
http://netbeans.org/downloads/
Fuentes de consulta
Bibliografía básica
Bibliografía complementaria
Presentación de la unidad
Propósito
Competencia específica
Es muy importante que captures todos los programas de ejemplo, para que analices su
sintaxis y puedas comprender mejor los temas vistos.
Los métodos (todos) tienen cierta estructura que los distinguen de las demás elementos
del lenguaje Java, la estructura clásica de un método es la siguiente:
tipo_devuelto nombre_método([parámetros]){
sentencia1;
sentencia2;
sentenciaN;
}
Nótese que el elemento [parámetros] está delimitado por corchetes, lo que quiere decir
que es un elemento opcional. Cuando los parámetros se manejan como lista de ellos, o
sea más de uno, se separa esta lista con una coma entre cada uno.
En Java, cuando se va a hacer uso de una variable primero se debe declarar, es decir,
indicarle al compilador que hemos reservado esa locación de memoria para poder alojar
un dato de interés para nuestra aplicación, de no ser así y aunque pongamos un
identificador a la variable, Java nos indicará que no está definida. En función a los datos
que almacenan las variables se clasifican en:
Para profundizar un poco más en el concepto de variable se dirá que una variable no es
nada más que un contenedor de bits que representan un valor. Se entenderá de la
siguiente manera:
Cuando se habla de variables primitivas, los bits que forman esta variable sólo
representan un número que coincide con el valor asignado a la misma variable y
como se indicó, puede quedarse conteniendo ese valor o puede cambiar a lo largo
de la ejecución del programa. Por ejemplo, relacionando lo expuesto ahora con el
tema de tipos de dato se tiene que hay variables de tipo byte (con una longitud de
8 bits en memoria) y puede almacenar números enteros con signo entre -128 y
127 (cuando no se utiliza el signo el valor puede ser hasta 255), de tipo int (con
una longitud de 32 bits en memoria) para almacenar números enteros con signo
entre -2,147,483,648 al 2,147,483,647, de tipo float con sus respectivos límites
hasta abarcar todos los tipos de dato. Visto de manera gráfica pudiera quedar
como sigue:
byte z = 5; // declaración de variable de tipo byte válida en java
Integer z=new Integer(100); //declaración de una variable de tipo objeto Integer, válido en
Java.
int b = 10;
// declaración de una variable 'b' de tipo entero
// con valor inicial establecido a 10.
Nombre_Clase referencia;
// declaración de una variable con identificador 'referencia'
// donde su tipo de dato será 'Nombre_Clase' o dicho de otra manera
// aquí es donde se crea el contenedor.
Nombre_Clase referencia2;
// mismo caso que la variable anterior,
// pero el identificador ahora es 'referencia2'.
referencia2 = referencia;
Ahora que se ha aclarado un poco la idea de qué es una variable, sus componentes
principales y el modo en que se hace una declaración de la misma, debemos considerar
las distintas partes del programa donde la utilizaremos. Es lo que se conoce como ámbito
de la variable.
Este concepto, es uno de los más importantes que debemos conocer cuando estamos
trabajando y manipulando variables. Se llama ámbito de una variable al lugar donde ésta
está disponible. Por lo general cuando declaramos una variable, sólo estará disponible en
el bloque de código (encerrado entre llaves) donde se ha declarado, que puede ser desde
el ámbito de la clase completa, el ámbito sólo de un método o incluso dentro del ámbito
de los elementos que conforman un método, por ejemplo una sentencia if, una sentencia
while, una sentencia for y entre todos los tipos disponibles que tenga Java. Por ejemplo:
Al compilar esta pequeña clase de ejemplo, se notará que el compilador de Java lanza un
mensaje de error que indicará que la variable a la que se hace referencia (variable con
identificador a) no ha sido encontrada, en otras palabras, su declaración no está dentro
del ámbito en donde se pretende usar. El mensaje de error del compilador de Java tendrá
un aspecto como se muestra en las siguientes imágenes.
Figura 1 Figura 2
Se puede notar claramente que en la primer imagen (Figura 1) el IDE nos está indicando
algún tipo de error en la línea 21, señalando la variable con identificador a como la posible
causa. En la segunda imagen (Figura 2) nos da los detalles completos de la causa del
error, el programador deberá entender que no se puede encontrar el símbolo (variable)
especificado.
Hay más normas de ámbito respecto a las variables miembro de una clase, donde
intervienen los modificadores de acceso public o private. Cuando una variable es
declarada con el modificador public se accede directamente a ellas a través de
nombre_clase.nombre_variable y en el caso de que una variable sea declarada con el
modificador private sólo se podrá acceder a ella mediante los métodos de la clase que lo
permitan.
Sin embargo, para hacer frente a esta pequeña inconveniencia del lenguaje, una
declaración de variable como static final se puede considerar una constante muy efectiva.
El modificador static permite el acceso a una variable miembro de una determinada clase
sin haber cargado una instancia de ésta donde será utilizada. El modificador final provoca
que la variable (su contenido) no pueda ser cambiada.
La siguiente declaración define la constante llamada PI cuyo valor está definido por el
número (3.1415927…).
Una vez que ya se conoció las generalidades sobre los métodos, se deberá conocer que
existen dos tipos cuando se habla de ellos:
Métodos que retornan valores.
Métodos que no retornan valores.
En este apartado se analizarán los métodos que no regresan valores.
2.2.1. Características
Cuando decimos que llamamos un método, estamos haciendo uso de las sentencias que
lo conforman. De igual manera se dice que se invoca al método.
Por definición del lenguaje Java, todos los métodos deberían regresar valores, excepto en
los casos explicados en el apartado anterior. Cuando los métodos declarados en Java
regresan valores, quiere decir que se espera recibir alguna respuesta o resultado de
alguna operación realizada por las sentencias que conforman su cuerpo. Para que un
método pueda regresar valores, deben estar involucrados varios factores que le ayuden o
“alimenten” para poder realizar dichas operaciones. Estos elementos básicos son:
Parámetros de entrada, que son las entradas propias del método que le ayudarán
a saber sobre qué se realizarán las operaciones indicadas en las sentencias que lo
conforman, aunque este apartado se puede considerar opcional.
Parámetros de retorno, que es la respuesta que nos regresará una vez que haya
ejecutado el cuerpo de sus sentencias.
En los apartados siguientes se explicará con más detalle los elementos mencionados y
algunos otros que son necesarios para los métodos que regresan valores.
Los parámetros de un método se pueden entender como los valores que éste recibe
desde la parte del código donde es invocado. Los parámetros pueden ser de tipos
primitivos (int, double, float, entre otros) u objetos.
Las partes del código que están resaltadas indican el retorno de parámetros del resultado
de obtener la potencia de los parámetros recibidos (base y potencia). El lector deberá
notar que el tipo de dato declarado en la definición del método es el mismo que el
utilizado en la variable de retorno (resultado), si fuera de otra manera, el compilador
lanzará un error de tipos incompatibles.
Cuando se invoque (llame) el parámetro que se quiera utilizar, deberemos pasarle los
parámetros indicados (necesarios) en su declaración. Los parámetros se escriben a
continuación del nombre del método que se quisiera utilizar, de igual manera entre
paréntesis pero al hacer la invocación no se indica el tipo de dato de los parámetros,
aunque las variables que enviemos forzosamente deberán coincidir con el tipo que
pretendemos utilizar. Por ejemplo, se completará el llamado del método presentado en el
punto anterior.
public static void main(String[] args){
int b = 3; //representando a la base
int p = 2; //representando a la potencia
obtener_potencia(b,p);
…
}
Como información al lector se debe aclarar que se omiten muchas partes de los métodos,
sólo son ejemplos ilustrativos de cada uno de los puntos.
También como punto importantísimo, recordando los tipos de variables, se dirá que en
Java los parámetros de tipo primitivo (int, long, double, …) siempre se pasan por valor. Las
variables de tipo objeto y arrays se pasan por referencia (referencia a su dirección de
memoria de alojamiento).
Para complementar todos los elementos de los métodos que regresan valores, se indicará
cuál es la forma correcta de llamar a los métodos, pasando los parámetros correctos y
recibiendo de manera adecuada los valores de retorno.
Donde:
r_potencia será el valor de recepción del parámetro devuelto por el método. De
igual manera deberá coincidir el tipo de dato de la variable de recepción, con el
tipo de dato indicado en el método. En este caso el método indica que regresará
un int, entonces el tipo de la variable deberá ser también int.
La llamada al método obtener_potencia será la conjunción de todos los puntos
explicados, necesitará un lugar donde depositar su valor de retorno (explicado en
el punto anterior) y pasar los parámetros necesarios después del nombre del
método, sin olvidar que todos los tipos de las variables deben coincidir (las
variables que se pasan como parámetros, la variable que se retorna desde el
método y la variable donde se recibe este valor de retorno). Se representa en esta
línea:
r_potencia = obtener_potencia(b,p);
Este foro de discusión tiene la finalidad de que des tu punto de vista sobre el uso de
variables y constantes, además de que intercambies ideas con tus compañeros sobre en
qué casos se utilizarían cada uno de esos usos.
Con el fin de distinguir la declaración de métodos en JAVA, revisa los siguientes métodos
declarados incorrectamente, identifica los errores planteados y corrígelos.
4. Guarda la actividad con el nombre POO1_U2_A2_XXYZ. Sustituye las XX por las dos primeras
letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del apellido
materno.
MÉTODO INCORRECTO
public void suma(int a int b){
int c=a+b;
return b;
}
public void area(int a, int b)
int c=a*b
return c;
}
public void divide(float a, float b){
int c=a/b;
return b;
}
public void resta(int a, int a){
imt c=a-b;
System.out.println(d);
}
public int areaCirculo(float r){
int b= 3.1416 * (r*r);
return;
}
Con el fin de distinguir los qué son los parámetros deberás elaborar una definición propia
de parámetros.
2. Guarda la actividad con el nombre POO1_U2_A3_XXYZ. Sustituye las XX por las dos
primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del
apellido materno.
Las estructuras alternativas son construcciones que permiten alterar el flujo secuencial de
un programa, de forma que en función de una condición o el valor de una expresión, el
mismo pueda ser desviado en una u otra alternativa de código (García, J., Rodríguez, J.,
Mingo, I., Imaz, A., Brazález, A., Larzabal, A. et al,. 2000).
2.4.1. If - else
Las llaves se utilizan para agrupar las instrucciones que se han de ejecutar, si solo
quieres que se ejecute una instrucción puedes omitirlas.
2.4.2. If anidado
package ejemplos;
/**
* @author ESAD
*/
public class estructuraIF {
En este ejemplo evaluamos que si su calificación está entre 90 y 100 se mostrará una
mensaje diciendo “Muy Bien”, si no tienes una calificación entre 90 y 100; pero si está
entre 80 y 90 te mostrará un mensaje diciendo “Bien”, y si no cumplió ninguna de las
anteriores y la calificación es menor de 70 mostrará un mensaje diciendo “Muy mal”.
Entonces como pudiste observar se pueden colocar condiciones múltiples como en este
ejemplo, donde no solo evaluó una calificación, sino un rango de calificaciones, para ello
se auxilió de los operadores lógicos y relacionales que se vieron en la unidad anterior.
Una sentencia case es una opción de los diferentes valores que puede tomar la expresión
que se evalúa, por cada valor permitido que la expresión pueda tomar representara una
sentencia case.
Las características más relevantes de switch son las siguientes (Gosling, J., Holmes, D. &
Arnold, K., 2001):
1. Cada sentencia case se corresponde con un único valor. No se pueden establecer
rangos o condiciones sino que se deben comparar con valores concretos.
2. Los valores no comprendidos en ninguna sentencia case se pueden gestionar en
default, que es opcional.
3. En la ausencia de break, cuando se ejecuta una sentencia case se ejecutan
también todas las case que van a continuación, hasta que se llega a un break o
hasta que termina el switch.
package ejemplos;
import javax.swing.JOptionPane;
/**
* @author ESAD
*/
public class ejemploSwitch {
switch(mes){
case 1: System.out.print("Enero");
break;
case 2: System.out.print("Febrero");
break;
case 3: System.out.print("Marzo");
break;
case 4: System.out.print("Abril");
break;
case 5: System.out.print("Mayo");
break;
case 6: System.out.print("Junio");
break;
case 7: System.out.print("Julio");
break;
case 8: System.out.print("Agosto");
break;
case 9: System.out.print("Septiembre");
break;
case 10: System.out.print("Octubre");
break;
case 11: System.out.print("Noviembre");
break;
case 12: System.out.print("Diciembre");
break;
default:System.out.print("Mes no válido");
}
}
}
Este ejemplo muestra que al inicio del programa se crea una variable llamada mes, la cual
almacena el número del mes indicado por el usuario, y muestra en la pantalla el nombre
del mes correspondiente, para identificar el nombre de mes utilizamos la sentencia switch
que para este ejemplo tiene 12 casos que son el número de meses que existen, al
encontrar el valor correspondiente mostrará el nombre del mes, y en caso de que el
usuario ingrese un número no valido como 20, el programa mostrará un mensaje diciendo
“Mes no válido”.
Entonces si requieres usar un programa donde las comparaciones sean muy específicas
puedes usar un switch, y en el caso de evaluar rangos, utiliza un if.
4. En caso de ser necesario, retroalimenta a tus compañeros para que modifiquen su programa.
Las estructuras de control cíclicas son bloques de instrucciones que se repiten un número
de veces mientras se cumpla una condición o hasta que se cumpla una condición (García,
J., Rodríguez, J., Mingo, I., Imaz, A., Brazález, A., Larzabal, A. et al., 2000).
Estas reglas son generales y algunos programadores se sienten más cómodos utilizando
principalmente una de ellas. Con mayor o menor esfuerzo, puede utilizarse cualquiera de
ellas indistintamente.
2.5.1. While
El ciclo while tiene como característica que primero evalúa la condición y solo si se
cumple realiza las instrucciones, así es que si la condición no es cumplida desde un inicio
el control del programa no entrará en el bloque de instrucciones que se encuentran dentro
del ciclo. Su declaración es como se muestra a continuación:
while (condicion){
Bloque de Instrucciones a repetir
}
La condición que se dé, deberá ser evaluada verdadera para que el control del programa
ingrese al bloque de instrucciones y deberá llegar en algún punto a que esa misma
condición se evalúe falsa y salga del bloque repetitivo. Si planteas mal la condición y ésta
nunca se evalúa como falsa, el programa se repetirá infinitamente, lo que provocará un
problema en la ejecución.
Veamos el siguiente ejemplo.
package ejemplos;
import javax.swing.JOptionPane;
/**
* @author ESAD
*/
public class ejemploWhile {
public static void main(String[] args) {
int n= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el 9"));
while(n != 9){
n= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el 9"));
}
}
}
2.5.2. Do - while
Este ciclo permite la ejecución del bloque repetitivo al menos una vez, se cumpla o no la
condición, pues ejecuta primero el bloque do y al finalizarlo evalúa la condición, si ésta se
cumple regresa a ejecutar nuevamente el bloque do, de lo contrario termina la ejecución.
do{
Bloque de instrucciones a repetir
}
While(condicion);
}
}
Como podemos observar el ciclo while es muy parecido al do-while, pero recordemos que
el while si desde un principio no se cumple la condición no entra al ciclo, y el do-while
primero entra y después evalúa.
Te pido compares los dos ejemplos, y veas que en el ciclo do-while la petición del número
la hacemos dentro del bloque que conforma el do, pues tenemos la certeza de que
entrará a ejecutar esta porción del programa, al menos una vez. Mientras que en el ciclo
while la petición se hace fuera del bloque de instrucciones que lo conforman, pues la
evaluación se realiza antes de entrar al ciclo.
2.5.3. For
Este ciclo es especialmente útil cuando de antemano conoces el número de veces que
quieres que se ejecute el mismo bloque de instrucciones, su declaración es como sigue:
Condición: se coloca la condición a evaluar en cada iteración del ciclo para que se siga
ejecutando el número de veces que se cumpla esta condición, pues el momento que la
condición se evalúe como falsa el ciclo dejará de repetirse.
Incremento: esta instrucción se evalúa como si fuese la última del bloque de instrucciones
e indica el incremento o decremento de la variable numérica de inicio para reevaluar la
condición en cada iteración.
Veamos el ejemplo:
package ejemplos;
import javax.swing.JOptionPane;
/**
* @author ESAD
*/
public class ejemploFor {
public static void main(String[] args) {
int n= Integer.parseInt(JOptionPane.showInputDialog("Cuántos números quieres ver"));
for(int i=1; i<=n; i=i+1){
System.out.print(i);
}
}
}
Este ejemplo pide al usuario un número, y muestra ese mismo número de elementos,
veamos, el inicio empieza en 1, la condición para seguir es que la variable i sea menor o
igual que el número dado por el usuario, y el incrementos será de uno en uno, de esta
manera pues la salida del programa al ingresar un 5 sería como se muestra a
continuación.
Otro punto importante respecto al ciclo for es que se puede anidar, esto se refiere a que
puedo utilizar un ciclo dentro de otro, a manera de explicación observa el siguiente código
y su salida.
package ejemplos;
import javax.swing.JOptionPane;
/**
* @author ESAD
*/
public class forAnidado {
public static void main(String[] args) {
int n= Integer.parseInt(JOptionPane.showInputDialog("Cuantos temas son"));
int m= Integer.parseInt(JOptionPane.showInputDialog("Cuantos subtemas contiene
cada tema"));
for(int i=1; i<=n; i=i+1){
for(int j=1; j<=m; j=j+1){
System.out.print(i+","+j);
System.out.print("\n");
}
}
}
}
Como se puede ver tenemos un ciclo dentro de otro, su manera de funcionar es que entra
al primero, después al segundo y hasta que el segundo termine sus repeticiones, el
primero volverá a incrementar su valor y volverá a entrar al segundo tomando sus valores
iniciales. Veamos la salida, en este ejemplo se indicó que los temas eran 3 y subtemas 2,
entonces se coloca el primer tema y sus respectivos subtemas 1,1 y 1,2, ya que termina
ese tema se sigue con el 2,1 y 2,2.
Nota: Si se quisieran anidar más de 2 ciclos for es posible realizarlo, tomando en cuenta
que siempre el ciclo que se encuentre más adentro será el que se realice primero.
package ejemplos;
import javax.swing.JOptionPane;
/**
* @author ESAD
*/
public class ejemploFor2 {
public static void main(String[] args) {
int n= Integer.parseInt(JOptionPane.showInputDialog("Cuántos números quieres ver"));
for(int i=n; i>0; i=i-1){
System.out.print(i);
System.out.print("\n");
}
}
}
Al realizar los cambios comentados podemos observar que la salida nos muestra los 5
números pero de manera descendente.
Con el fin de distinguir los métodos en JAVA y sus tipos, identifica los métodos que
devuelven valor y los que no devuelven valor, de modo tal que se cree un programa con 3
métodos de cada tipo.
2. Dentro de la clase Main elabora un programa con 6 métodos, donde se definan dos números
que sume, reste y multiplique números enteros y estos métodos regresen el resultado.
3. Además, diseña métodos para calcular el área de un cuadrado, área de un círculo y área de un
triángulo y que estos métodos no devuelvan valor.
4. Guarda la actividad con el nombre POO1_U2_A5_XXYZ. Sustituye las XX por las dos
primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del
apellido materno.
Autoevaluación
Para reforzar los conocimientos relacionados con los temas que se abordaron en esta
segunda unidad del curso, es necesario que resuelvas la autoevaluación de la unidad.
Como parte de la evaluación de esta unidad, realiza una aplicación cuyo propósito es que
identifiques los componentes de un programa y puedas emplearlos. El programa
solicitará un número al usuario; si el número es par, que calcule su factorial; si el número
es impar, que muestre el mismo número de elementos de la serie de Fibonacci, utilizando
métodos que devuelven valor y que no devuelven.
2. Dentro de la clase Main elabora un programa donde se definan dos métodos uno que calcule el
factorial y otro que realice la secuencia de Fibonacci, para después mostrar el resultado en la
pantalla. La llamada a estos métodos estará dada por la solicitud de un número al usuario, si este
es par que calcule su factorial, si es impar, que muestre es mismo número de elementos de la serie
de Fibonacci, utilizando métodos que devuelven valor y que no devuelven.
3. Guarda la evidencia con el nombre POO1_U2_EA_XXYZ. Sustituye las XX por las dos
primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial del
apellido materno.
Cierre de la unidad
Has concluido la unidad 2 del curso. A lo largo de ésta has visto lo que es una variable,
su ámbito y declaración, así como las generalidades de los métodos, sus características,
llamadas y tipos de parámetros que se manejan. Posteriormente te involucraste
conociendo las estructuras de control selectivas, como lo son el If-else, If anidado y
switch-case.
Al final de la unidad también se vieron las estructuras de control cíclicas while, do-while y
for, cuyo propósito ha sido que obtengas conocimientos sobre estructuras de control y
logres aplicarlas en la resolución de problemas y creación de programas para dichas
soluciones.
Es aconsejable que revises nuevamente la unidad en caso de que los temas que se
acaban de mencionar no te sean familiares o no los recuerdes, de no ser este tu caso, ya
estás preparado(a) para seguir con la unidad 3, en donde continuarás con la revisión de
herencia, polimorfismo y excepciones en un programa JAVA. Todo ello con el fin de
obtener el conocimiento necesario para comenzar a realizar pequeños programas
computacionales al final de la cuarta y última unidad del curso de Programación Orientada
a Objetos I.
Fuentes de consulta
García, J., Rodríguez, J., Mingo, I., Imaz, A., Brazález, A., Larzabal, A. et al. (2000)
Aprenda JAVA como si estuviera en primero. España: Escuela Superior de
Ingenieros, TECNUM. Recuperado el 1 de Marzo del 2011, de
http://www.tecnun.es/asignaturas/Informat1/AyudaInf/aprendainf/Java/Java2.pdf
Gosling, J., Holmes, D. & Arnold, K. (2001) El lenguaje de programación Java TM.
Madrid: Addison-Wesley. Recuperado el 1 de marzo del 2011, de
http://icesecurity.org/programacion/JAVA/Libro_Java-SP.pdf
Presentación de la unidad
Propósito
Competencia específica
Es muy importante que captures todos los programas de ejemplo, para que analices su
sintaxis y puedas comprender mejor los temas vistos.
3.1. Herencia
La herencia es una propiedad del lenguaje que nos permite definir objetos en base a otros
ya existentes y así poder añadirles nuevas características (extenderlos). La nueva clase
es llamada subclase o clase extendida y la clase que hereda sus métodos y atributos se
llama superclase.
En el lenguaje Java existen dos categorías en las cuales puede agruparse las clases:
superclase, que es la clase existente y subclase, que es la clase derivada de la primera.
Otro término usado comúnmente para la superclase es clase padre y la subclase también
se le conoce como clase hija. Para entender mejor la clase derivada se dirá que es
aquella que añade variables de instancia y métodos a partir de los heredados (obtenidos)
desde la clase padre. En la siguiente figura se ejemplifica el modo en que se heredan sus
métodos y atributos entre las clases. La clase padre es Persona y sus subclases son
Estudiante y Profesor, debe notarse de igual manera que la clase Profesor a su vez funge
con dos roles distintos: es subclase de la superclase Persona y es superclase de las
subclases Asignatura y Base.
Dibujacirculo que tendrá la misma funcionalidad que su clase padre, más un método
añadido: imprimeCirculo.
La solución descrita funciona, sin embargo no es una solución óptima y siendo un poco
más exigentes carece de elegancia. El problema que se presenta en esta solución es el
doble trabajo que involucra escribir los métodos presentados y que no tienen injerencia
en el dibujado del círculo.
Deberás notar que se obvia la declaración de dos clases: Color y DrawWindow, se toma
sólo como ejemplo ilustrativo. La palabra reservada extends le indica al compilador de
Java que Dibujacirculo es una subclase de circulo, lo que significa que ésta heredará por
completo sus métodos y atributos con los modificadores de acceso que se le indicaron en
la clase padre.
En el lenguaje Java cada clase que se escribe es una superclase por definición. Si no se
escribe específicamente la palabra reservada extends, la superclase será la clase Object,
que por muchas razones es un tipo especial de clase, se listan a continuación:
1. Desde la definición de Java, es la única clase que no tiene superclases.
2. Los métodos definidos en la clase Object pueden ser invocados desde cualquier
clase Java.
Por lo descrito anteriormente, todas las clases en java pueden ser superclases, se deberá
marcar una jerarquía de clases en Java donde su raíz deberá ser la clase Object, se
presenta una imagen de su posible representación con nuestro ejemplo citado de la clase
círculo.
Con la salida a la luz del paradigma de programación orientado a objetos, de igual manera
surgieron muchos problemas inherentes a la comprensión sobre la forma de representar
cosas y más aún conceptos en forma de un objeto en lenguaje de programación Java.
Por lo descrito, muchas ocasiones se desea representar conceptos abstractos en forma
de una clase que pueda ser manejada por Java, pero por la misma definición de su
abstracción no se pueden instanciar a partir de ellas un nuevo objeto. Consideremos por
ejemplo, la comida en el mundo real. ¿Se puede tener una instancia (un ejemplar) de
comida? No, aunque sí se pueden tener instancias de manzanas, chocolates o cualquier
otro alimento. La comida representa el concepto abstracto de cosas que se pueden comer
y no tiene sentido que tenga instancias ya que no es un objeto concreto, sólo una
abstracción de un concepto más amplio. Otro ejemplo puede ser la clase abstracta
FiguraTresDimensiones; de ella se pueden definir clases concretas, tales como Esfera,
Cilindro, Cono.
Bajo la definición anterior no se puede comprender la utilidad de tener una clase abstracta
de manera pronta, sin embargo su utilidad se ve definida cuando sirven para heredar a
otras subclases características generales del concepto abstracto que representan, pero
de ellas no se puede instanciar objetos con el operador new. Las clases a partir de las
cuales se pueden crear instancias se denominan clases concretas (Niemeyer & Peck,
1997).
Una clase abstracta es una clase que contiene los nombres de los comportamientos sin
las implementaciones que ejecutan esos comportamientos. Los objetos no se pueden
instanciar de una clase abstracta.
Cuando se hace la definición (declaración) de una clase abstracta deberá ser antecedida
por el modificador abstract. Este tipo de clases puede contener métodos abstractos, que
como se podrá imaginar son sólo la declaración de los mismos, pero sin la
implementación de las instrucciones que se esperaría para cumplir el propósito para los
cuales fueron escritos. La implementación de dichos métodos se hace en las subclases.
Para que un método pueda declararse como abstracto debe cumplir con dos condiciones
básicas:
1. No ser método privado.
2. No ser método estático.
3.2. Polimorfismo
Las clases se declaran como finales cuando se pretende que no se pueda derivar de ésta.
Es decir si se crea una clase y se quiere que no se creen clases hijas de ésta (que
hereden), entonces la clase deberá ser declarada como final, para indicar que no se
pueden crear otras clases a partir de ella y que terminan con una cadena de herencia.
Que como se muestra solo hace falta añadir la palabra final al inicio de la declaración de
la clase.
Por su parte los métodos finales son aquellos que no pueden ser redefinidos, es decir que
en ellos no se podrá aplicar ni herencia ni polimorfismo. Su declaración al igual que la
clase final solo consta de anteponer la palabra reservada final a la declaración de método
en cuestión.
Entonces se usará la palabra final en las clases y métodos que ya no se puedan heredar,
ni redefinir, es decir, aquellos que no deban ser modificados en ninguna otra clase.
3.2.2. Interfaces
Una interfase se puede considerar una clase abstracta de hecho, y en ella se toma en
cuenta lo siguiente (Flanagan, 1997):
Imaginemos que tenemos la clase abstracta identificada como fruta y dentro de esta clase
está declarado el método pelarFruta. De esta clase abstracta se hereda este método (y
otros tantos que conciernen a todas las frutas) hacia las subclases manzana y naranja; al
tratar de utilizar el método pelarFruta deberá sobrecargarse porque la acción de pelar la
fruta se hace de manera distinta entre una manzana y una naranja, que son las clases a
donde se heredó este método. Así pues en cada clase donde se herede el método puede
implementarse de manera diferente el método, se dice que se sobrecargan sus funciones
pues son diferentes para cada una de las subclases.
La sobrecarga de los operadores permite redefinir las funciones que se le asignan por
definición a un operador, por ejemplo el operador “+” (más) y el operador “.” (punto), se
pueden utilizar para realizar otras funciones que las regulares. Como ejemplo práctico y
conocido, el operador “+” en el mundo Java sirve para dos cosas, al estar sobrecargado:
2. Para realizar la operación de unión, cuando uno de sus operando es una dato de
tipo String.
El compilador decide qué uso se le dará en base a los operando de los cuales esté
acompañado.
Esta actividad tiene como finalidad que reflexiones sobre el concepto y uso de la
herencia y el polimorfismo.
2. Guarda la actividad con el nombre POO_U3_A2_XXYZ. Sustituye las XX por las dos
primeras letras del primer nombre, la Y por la inicial del apellido paterno y la Z por la inicial
del apellido materno.
3.3. Excepciones
Cuando un programa Java viola las restricciones semánticas del lenguaje (se produce un
error), la máquina virtual Java comunica este hecho al programa mediante una excepción.
Por tanto la manera más simple de decirlo es que una excepción es un error que ha
ocurrido en un programa en ejecución.
La manera de controlar las excepciones es mediante una sentencia llamada try – catch,
que si lo traducimos a español sería algo como intenta – atrapa, y realmente esto es lo
que hace la sentencia, pues dentro del try se coloca el código vulnerable a errores, para
que el programa lo “intente”, y en caso de que ocurra un error lo “atrape” en la sentencia
catch. Veamos el siguiente ejemplo:
Como se dijo anteriormente en el código podemos ver que el bloque de sentencias que
pudiera tener un error se coloca dentro del try{}, y en el catch(){} se coloca el tipo de error
y su nombre dado, que por lo general siempre es e, entonces una vez que atrapa e error
lo imprime a pantalla para que el usuario conozca el error, todo esto sin provocar un cierre
inesperado del código.
En el momento en que es lanzada una excepción, la máquina virtual Java recorre la pila
de llamadas de métodos en busca de alguno que sea capaz de tratar la clase de
excepción lanzada. Para ello, comienza examinando el método donde se ha producido la
excepción; si este método no es capaz de tratarla, examina el método desde el que se
realizó la llamada al método donde se produjo la excepción y así sucesivamente hasta
llegar al último de ellos. En caso de que ninguno de los métodos de la pila sea capaz de
tratar la excepción, la máquina virtual Java muestra un mensaje de error y el programa
termina.
Por ejemplo si tengo un metodo1 que dentro hace una llamada al metodo2, y el metodo2
manda llamar al metodo3, y el metodo3 llama al metodo4, lo que pasa si ocurre un error
en el metodo1, es que se busca un manejo de excepciones en el metodo1, pero si no se
encuentra se va al metodo2 para ver si en este método si se realiza el manejo de la
excepción, pero si ahí tampoco se hizo nada, se va al metodo3 en búsqueda del manejo
de la excepción, por último si tampoco en el metodo3 se hizo nada, se va al metodo4 a
buscar el manejo de la excepción, a esto se refiere el texto de arriba sobre “ ”, a ir
buscando en las llamadas hasta encontrar donde se pueda manejar la excepción, pero si
en ninguno de los métodos se realizó, entonces inevitablemente la excepción hará que el
sistema falle.
Con el fin de tener claro el tema de excepciones en JAVA, realiza un ensayo con las
siguientes características:
1. Elabora un ensayo donde plasmes tu percepción sobre el uso y utilidad que brindan
las excepciones para un programador. No olvides incluir las fuentes que consultes.
Autoevaluación
Para reforzar los conocimientos relacionados con los temas que se abordaron en esta
primera unidad del curso, es necesario que resuelvas la autoevaluación de la unidad.
Recuerda que es muy importante leer cuidadosamente los planteamientos indicados y
elegir la opción adecuada para cada uno.
1. En NetBeans crea un nuevo proyecto, dentro de éste crea las clases abstractas e
interfaces proporcionadas y elabora sus respectivas clases de implementación.
* Recuerda que puedes volver a enviar tu archivo tomando en cuenta las observaciones
de tu Facilitador(a).
Autorreflexiones
Consulta la página oficial del lenguaje JAVA, donde podrás encontrar manuales de
referencia sobre el manejo de la herencia, el polimorfismo y las excepciones.
Java: http://www.java.com/es/
Fuentes de consulta
Flanagan, D. (1997) Java in a NutShell, The Java Reference Library, versión 1.2.
México: O'Reilly & Associates.
Joyanes, L. & Fernández, M. (2001) Java 2: manual de programación. México:
McGrawHill.
Niemeyer, P. & Peck, J. (1997) Exploring Java, The Java Reference Library,
versión 1.2. México: O'Reilly & Associates.
Unidad 4. Arreglos
Presentación de la unidad
Esto te servirá para el manejo de información obtenida de una base de datos, así como la
estructuración de datos en tablas, que son temas que tratarás en POO2.
En esta Unidad es necesario que tú, como estudiante, captures todos los programas de
ejemplo, para que analices su sintaxis y así comprendas mejor los temas vistos.
Propósito
Competencia específica
Construir programas para el manejo de datos del mismo tipo (carácter, cadena, entero o
decimal) a través de arreglos aplicados en problemas matemáticos simples.
Un arreglo es una estructura de datos que contiene una serie de variables a las que se
accede a través de los índices calculados.
Las variables contenidas en un arreglo, también llamados los elementos del arreglo, son
todos del mismo tipo, y este tipo se llama el tipo de elemento del arreglo. Un arreglo tiene
un rango que determina el número de índices asociados a cada elemento del arreglo. El
rango de un arreglo también se conoce como las dimensiones del arreglo. Un arreglo
con un rango de 1 se denomina arreglo unidimensional. Un arreglo con un rango mayor
que 1 se llama un arreglo multidimensional. Los arreglos multidimensionales con un
tamaño específico se refieren a menudo como arreglos de dos dimensiones, los arreglos
de tres dimensiones, y así sucesivamente.
Cada dimensión de un arreglo tiene una longitud asociada que es un número entero
mayor o igual a cero. Las longitudes de las dimensiones no son parte del tipo del arreglo,
sino que se establecen cuando una instancia del tipo arreglo se crea en tiempo de
ejecución. La longitud de una dimensión determina el rango de validez de los índices de
esa dimensión: Por una dimensión de longitud N, los índices pueden variar de 0 a N-1. El
número total de elementos de un arreglo es el producto de las longitudes de cada
dimensión del arreglo. Si una o más de las dimensiones de un arreglo tienen una longitud
de cero, se dice que el arreglo está vacío. El tipo de elemento de un arreglo puede ser
cualquier tipo de dato, incluyendo él mismo (Hejlsberg, 2011: 626), es decir, en lugar de
cada posición contenga un dato, puede contener un arreglo completo.
4.1.1. Declaración
Además, como ya se mencionó, se pueden usar en Java arrays de cualquier tipo de dato
soportado, incluso los definidos por el usuario:
“La memoria necesaria para almacenar los datos que componen el array se buscará en
memoria dinámica a la hora de instanciar y crear realmente el array” (Froufe, 2009: 35).
Igual que con cualquier variable utilizada, en el lenguaje Java necesitan ser inicializadas a
un valor. Bajo esta premisa, cuando se declara (crea) un array en Java se inicializa
automáticamente, dependiendo de estos tres casos:
Una vez que se ha instanciado un array, se puede acceder a los elementos de éste
utilizando un índice, de forma similar a la que se accede en otros lenguajes de
programación. Los índices de un array siempre empiezan por 0 (cero) (Froufe, 2009: 35).
Actividad 1. Arreglos
El propósito de esta actividad es quereflexiones sobre las diferencias existentes entre los
diversos tipos de arreglos revisados en la asignatura.
4. Elabora las diferencias entre los diversos tipos de arreglos, esto será como conclusión
del foro; hazlo basándote en las aportaciones de los compañeros(as).
4.1.2. Recorrido
Los elementos contenidos en los arrays están controlados por la posición que ocupen
dentro del array. Así, en el ejemplo anterior se tenía una declaración de un array de tipo
String que contendría 4 elementos, refiriéndose a los nombres propios de 4 personas:
Donde se indica al arreglo que se quiere imprimir el valor que está en la posición i-ésima,
esta instrucción se le indica al lenguaje Java cuando se pone el nombre del arreglo con el
cual se quiere trabajar, seguido de la posición que se desea recuperar (para impresión,
operaciones, cálculos, entre otros) encerrado entre corchetes([]). La salida de estas
instrucciones escritas en lenguaje Java, al compilar y ejecutar el programa (se obvian las
partes faltantes de la clase por cuestiones didácticas) sería la siguiente:
Imagina la cantidad de líneas necesarias para imprimir el nombre de todos los alumnos
que pertenecen a una universidad cuya matrícula es un total de 5,000 alumnos. Como se
podrá deducir fácilmente se necesitarían 5,000 líneas como las anteriores.
Para solucionar la cuestión anterior de forma un tanto más sencilla se utilizan ciclos, que
como ya se sabe, facilitan la ejecución de operaciones secuenciales y repetitivas pero
necesarias, como en el caso de los arrays. Además que los ciclos son controlados por
índices (su comienzo y su fin) y ésta es la misma forma de acceder a los elementos de un
array, como ya se había explicado. A continuación se presenta la misma impresión del
contenido del array nombres, pero utilizando un ciclo for:
Y la salida será:
Según las nuevas instrucciones, se introdujeron algunas variaciones para poder hacer el
recorrido funcional y se explica a continuación: Cuando se declara un arreglo se indica el
total de elementos que contendrá dentro de él (límite del arreglo); este mismo límite es el
total de repeticiones que deberá ejecutar el ciclo for, indicado con i<4 (ya que si se indica
un número mayor, Java lanzará una excepción indicando que se intenta acceder a una
locación de memoria no reservada o inexistente). De igual manera el inicio del array debe
comenzar por el número 0 (cero) y esto se indica en el ciclo for al hacer la declaración i=0
que indica que desde esa posición comenzará a iterar.
4.1.3. Operaciones
obtienen sus elementos, haciendo un profundo énfasis en la importancia que tienen los
índices para ello.
y se quiere hacer una suma y multiplicación punto a punto (posición a posición) de cada
uno de sus elementos, y almacenarlos en un tercer array para cada operación sugerida,
luego imprimir el resultado de la acumulación de las operaciones. Se ejemplifica con la
siguiente porción de código:
Nótese la importancia de los índices para poder acceder a los elementos de los arrays y
de la misma manera para almacenar resultados.
Se puede utilizar un mismo contador para n arrays, siempre y cuando éstos sean del
mismo tamaño, como en el ejemplo anterior, donde se sumó y multiplicó en un mismo
ciclo. Solo en las impresiones, dado que se buscaba que el resultado se viera de manera
independiente, se utilizaron más ciclos for, tantos como números de resultados se quiera
mostrar.
Esta actividad tiene como finalidad que identifiques la declaración y recorrido de arreglos
unidimensionales en Java.
7. Dentro de la clase Main crea un método, donde se solicite al usuario un número para
determinar el tamaño de un arreglo, seguido a esto, se solicite al usuario ingrese
elementos para llenar el arreglo, y por último se muestre ese mismo arreglo en una salida
pero con cada elemento elevado al cubo. La llamada a esto método estará dada en el
método main.
Los arreglos vistos en la sección anterior solo son de una dimensión, es decir solo se
manejaban a manera de renglón (o fila).
4.2.1. Declaración
Los arreglos multidimensionales tienen más de una dimensión. En Java, las dimensiones
se manejan por medio de corchetes (muy parecido a los arrays unidimensionales), dentro
de los cuales se escribe cada dimensión (cantidad de datos que guardará). Cada
dimensión irá dentro de un corchete. La sintaxis general para declarar e instanciar un array
es:
Además, como ya se mencionó, se pueden usar en Java arrays de cualquier tipo de dato
soportado, incluso los definidos por el usuario:
Ahora bien, la declaración de los arrays en Java se hace mediante una variable
referenciada, es decir, no se guarda el valor del contenido del array, lo que se guarda es
una referencia de la locación de memoria donde están alojados dichos datos. Con lo que
se acaba de ver, fácilmente se puede deducir que los arrays son objetos.
Declararlo vacío.
La estructura general, si pudiera observarse la reserva de memoria que hace Java sobre
la memoria principal de la computadora, sería como sigue:
Observa que la estructura que se muestra, coincide perfectamente con las dimensiones
declaradas en el arreglo intnumeros[][] = new int[3][3]; donde el número contenido en el
primer corchete corresponde al número de filas que contendrá el array, por ende, el
número contenido en el segundo corchete corresponde al número de columnas que
contendrá el array, de esta manera se analizará una estructura diferente, como la que
sigue:
Quedaría así:
Declararlo con valores iniciales es un poco diferente, como la declaración para arrays
unidimensionales, pues se debe especificar explícitamente el contenido de cada
dimensión del array.
4.2.2. Recorrido
Se puede acceder a los valores de los elementos de un arreglo bidimensional a través del
nombre del arreglo y dos subíndices. Los subíndices deben escribirse entre corchetes y
representan la posición del elemento en el arreglo. Así, es posible referirse a un elemento
del arreglo escribiendo el nombre del arreglo y los subíndices del elemento entre
corchetes. Los valores de los subíndices empiezan en cero para el primer elemento, hasta
el tamaño del arreglo menos uno.
4.2.3. Operaciones
Nota la importancia de los índices para poder acceder a los elementos de los arrays y de
la misma manera para almacenar resultados.
Se puede utilizar un mismo contador para n arrays, siempre y cuando éstos sean del
mismo tamaño, como en el ejemplo anterior donde se sumó y multiplicó en un mismo
ciclo. Sólo en las impresiones como se buscaba que el resultado se viera de manera
independiente, se utilizaron más ciclos for, tantos como números de resultados se quiera
mostrar.
2. Dentro de la clase Main crea un método, donde se soliciten al usuario dos números X
y Y, y sean X el número de filas, Y el número de columnas de un arreglo, seguido a esto,
se solicite al usuario ingrese elementos para llenar el arreglo, y por último se muestre ese
mismo arreglo en una salida pero en orden inverso. La llamada a esto método estará
dada en el método main.
3. Guarda la actividad con el nombre POO_U4_A3_XXYZ. Sustituye las XX por las dos
primeras letras de tu primer nombre, la Y por la inicial de tu apellido paterno y la Z por la
inicial de tu apellido materno.
Autoevaluación
Para reforzar los conocimientos relacionados con los temas que se abordaron en esta
primera unidad del curso, es necesario que resuelvas la Autoevaluación de la unidad.
Recuerda que es muy importante leer cuidadosamente los planteamientos indicados y
elegir la opción adecuada para cada uno.
Como parte de la evaluación de esta unidad, debes realizar un programa cuyo propósito
es que logres identificar los componentes de un programa modular y puedas aplicarlos.
5. En NetBeans crea un nuevo proyecto, y crea tantas clases como ejercicios se han
realizado a lo largo del cuatrimestre, donde cada clase incluya cada programa. En la clase
Main se debe contar con un mensaje tipo menú al usuario, y este podrá elegir ejecutar
cualquier programa; en el método main se debe tener un switch que tenga la llamada a
todos los métodos en forma de menú y que al elegir el usuario un número se ejecute ese
programa.
* Recuerda que puedes volver a enviar tu archivo tomando en cuenta las observaciones
de tu Facilitador(a).
Autorreflexiones
Consulta la página oficial del lenguaje Java, donde podrás encontrar manuales de
referencia sobre arreglos.
Java: http://www.java.com/es/
Fuentes de consulta