04_PD_DS_POO1

Programación orientada a objetos I Programa desarrollado

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software 1

CARRERA: Ingeniería en Desarrollo de Software

Cuatrimestre 04

Programa de la asignatura:

Programación Orientada a Objetos I

Clave: 160920414 / 150920414



Índice

I. INFORMACIÓN GENERAL DE LA ASIGNATURA ............................................. 7 a. Ficha de identificación ............................................................................................................. 7

b. Descripción ............................................................................................................................... 7

c. Fundamentación de la asignatura ......................................................................................... 8

d. Propósito ................................................................................................................................... 9

e. Competencia(s) a desarrollar ................................................................................................. 9

f. Temario ....................................................................................................................................... 9

g. Metodología de trabajo ......................................................................................................... 11

h. Evaluación ............................................................................................................................... 12

i. Fuentes de consulta ................................................................................................................ 13

II. DESARROLLO DE CONTENIDOS POR UNIDAD ........................................... 15 a. Unidad 1. Introducción a JAVA ............................................................................................ 15

Presentación de la unidad ......................................................................................................... 15

Propósitos de la unidad ............................................................................................................. 15

Competencia específica ............................................................................................................ 15

Actividad 1. Presentación .......................................................................................................... 15

1.1. Características de la Programación Orientada a Objetos ............................................ 16

1.1.1. Abstracción ....................................................................................................................... 16

1.1.2. Polimorfismo ..................................................................................................................... 17

1.1.3. Encapsulación .................................................................................................................. 17

1.1.4. Herencia ............................................................................................................................ 17

1.1.5. Programación orientada a objetos vs estructurada ................................................... 18

Actividad 2. Diferencias entre Programación estructurada y POO ..................................... 19

Actividad 3. Características de JAVA ...................................................................................... 20

1.2. Características del lenguaje JAVA ................................................................................... 20

1.2.1. Generalidades de JAVA ................................................................................................. 21



1.2.2. Máquina virtual de JAVA ................................................................................................ 26

1.2.3. Entorno de desarrollo y configuración .......................................................................... 27

1.2.4. Tipos de datos soportados en JAVA ............................................................................ 30

Actividad 4. Tipos de datos ....................................................................................................... 32

1.2.5. Operadores aritméticos, lógicos y relacionales .......................................................... 33

Actividad 5. Operadores ............................................................................................................ 36

1.2.6. Conversión de tipos de datos ........................................................................................ 37

1.3. Organización de un programa .......................................................................................... 38

1.3.1. Estructura General .......................................................................................................... 39

1.3.2. Convenciones de la programación ............................................................................... 42

1.3.3. Palabras reservadas ....................................................................................................... 43

1.3.4. Estructura de una clase .................................................................................................. 44

1.3.5. Declaración de objetos y constructores ....................................................................... 45

Autoevaluación ........................................................................................................................... 46

Evidencia de aprendizaje. Programa en JAVA ...................................................................... 47

Cierre de la unidad ..................................................................................................................... 47

Para saber más ........................................................................................................................... 48

Fuentes de consulta ................................................................................................................... 48

UNIDAD 2. MÉTODOS Y ESTRUCTURAS DE CONTROL ................................. 50 Presentación de la unidad ......................................................................................................... 50

Propósito ...................................................................................................................................... 50


Consideraciones específicas de la unidad: actividades, requerimientos de asignatura,

etc. ................................................................................................................................................ 50

2.1. Generalidades de los métodos ......................................................................................... 51

2.1.1. Declaración y ámbito de variables ................................................................................ 51

2.1.2. Declaración de constantes ............................................................................................. 55

2.2. Métodos que no devuelven valores ................................................................................. 56

2.2.1. Características ................................................................................................................. 56

2.2.2. Llamada de métodos ...................................................................................................... 56



2.3. Métodos que devuelven valores ....................................................................................... 57

2.3.1. Recepción de parámetros .............................................................................................. 58

2.3.2. Retorno de parámetros ................................................................................................... 58

2.3.3. Paso de parámetros ........................................................................................................ 59

2.3.4. Llamada de métodos ...................................................................................................... 59

Actividad 1. Tipos de variables y constantes ......................................................................... 60

Actividad 2. Detección de errores ............................................................................................ 60

Actividad 3. Sobre parámetros ................................................................................................. 61

2.4. Estructuras de control selectivas ...................................................................................... 62

2.4.1. If - else ............................................................................................................................... 62

2.4.2. If anidado .......................................................................................................................... 63

2.4.3. Switch - case .................................................................................................................... 64

Actividad 4. Programa de horóscopo ...................................................................................... 66

2.5. Estructuras de control cíclicas .......................................................................................... 67

2.5.1. While .................................................................................................................................. 67

2.5.2. Do - while .......................................................................................................................... 68

2.5.3. For ...................................................................................................................................... 69

Actividad 5. Programa retorno de parámetros ....................................................................... 72

Autoevaluación ........................................................................................................................... 72

Evidencia de aprendizaje. Programa de series numéricas .................................................. 73

Cierre de la unidad ..................................................................................................................... 73

Para saber más ........................................................................................................................... 74


UNIDAD 3. CARACTERÍSTICAS DE POO Y EXCEPCIONES ............................ 75 Presentación de la unidad ......................................................................................................... 75

Propósito ...................................................................................................................................... 75


Consideraciones específicas de la unidad ............................................................................. 75

3.1. Herencia ............................................................................................................................... 75

3.1.1. Subclases y superclases ................................................................................................ 76



3.1.2. Jerarquía de la herencia ................................................................................................. 78

3.1.3. Clases y métodos abstractos ........................................................................................ 78

3.2. Polimorfismo ........................................................................................................................ 79

3.2.1. Clases y métodos finales ............................................................................................... 80

3.2.2. Interfaces .......................................................................................................................... 80

3.2.3. Sobrecarga de métodos ................................................................................................. 81

3.2.4. Sobrecarga de operadores ............................................................................................ 82

Actividad 1. Herencia y polimorfismo ...................................................................................... 82

Actividad 2. Cuadro sinóptico ................................................................................................... 82

3.3. Excepciones ........................................................................................................................ 83

3.1.1. Sentencia Try-catch ........................................................................................................ 83

3.1.2. Tipos de errores ............................................................................................................... 84

3.1.3. Jerarquía de las excepciones ........................................................................................ 84

Actividad 3. Manejo de excepciones ....................................................................................... 85

Autoevaluación ........................................................................................................................... 86

Evidencia de aprendizaje. Implementación de clases abstractas ...................................... 86

Para saber más ........................................................................................................................... 88


UNIDAD 4. ARREGLOS ....................................................................................... 89 Presentación de la unidad ......................................................................................................... 89

Propósito ...................................................................................................................................... 89


4.1. Arreglos unidimensionales ................................................................................................ 89

4.1.1. Declaración ....................................................................................................................... 90

Actividad 1. Arreglos .................................................................................................................. 92

4.1.2. Recorrido .......................................................................................................................... 92

4.1.3. Operaciones ..................................................................................................................... 94

Actividad 2. Operaciones con arreglos ................................................................................... 96

4.2 Arreglos multidimensionales .............................................................................................. 96

4.2.1. Declaración ....................................................................................................................... 97



4.2.2. Recorrido .......................................................................................................................... 99

4.2.3. Operaciones ................................................................................................................... 100

Actividad 3. Inversión de arreglos .......................................................................................... 102

Autoevaluación ......................................................................................................................... 102

Evidencia de aprendizaje. Menú del curso ........................................................................... 102

Para saber más ......................................................................................................................... 103

Fuentes de consulta ................................................................................................................. 104



I. Información general de la asignatura

a. Ficha de identificación

Nombre de la Licenciatura

o Ingeniería:

Ingeniería en Desarrollo de Software

Nombre del curso o

asignatura

Programación Orientada a Objetos I

Clave de asignatura: 160920414 / 150920414

Seriación: 160920518 / 150920518

160920622 / 150920622

Cuatrimestre: 04

Horas contempladas: 72

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.

El lenguaje de programación JAVA es un lenguaje basado en C, cuyo enfoque está

dirigido a la POO, por ello será el utilizado en este curso. Una de las ventajas de utilizar

este lenguaje es que también encontramos su compilador de manera libre, como



Netbeans, Eclipse, etcétera. El principal elemento de la programación orientada a objetos

es la reutilización de código para poder optimizar el desarrollo de software basado en las

técnicas para la solución de problemas.

La asignatura de Programación orientada a objetos I forma parte del 4º cuatrimestre de la

Ingeniería en Desarrollo de software. Las materias previas son Fundamentos de

programación y Habilidades del pensamiento, las cuales sirven de base para POO I y

ésta, a su vez, servirá para continuar con las materias de POO II, POO III, Programación

NET I, NET II y NET III, entre otras.

La materia de POO I está conformada por cuatro unidades:

1. Introducción a JAVA

2. Métodos y estructuras de control

3. Características de programación orientada a objetos y excepciones

4. Arreglos

En la unidad 1 se delineará el concepto de la programación orientada a objetos,

describiéndose los elementos que la integran así como el lenguaje a implementar, JAVA,

del cual se abordarán sus características. Asimismo, se determinará la estructura de un

programa. En la unidad 2 se identificará la forma en que se codifican los métodos y se

ilustrarán las estructuras de control. A continuación, en la unidad 3, se distinguirán las

características de la programación orientada a objetos, entre las que se encuentran:

herencia y polimorfismo. También se evocará el manejo de excepciones, errores,

sentencias de error y jerarquías. Finalmente, la unidad 4 introducirá el manejo de arreglos

unidimensionales y multidimensionales: su declaración, recorrido y operaciones.

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

Favorecer al logro del aprendizaje orientado a la generación de aplicaciones de software.

Así mismo su importancia radica en establecer las bases de la programación para que el

alumno desarrolle habilidades para la implantación de aplicaciones de software que

satisfagan las necesidades de las empresas.

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.

Unidad 1. Introducción a JAVA



1.1 Características de la programación orientada a objetos

1.1.1 Abstracción

1.1.2 Polimorfismo

1.1.3 Encapsulación

1.1.4 Herencia

1.1.5 Programación orientada a objetos vs estructurada.

1.2 Características del lenguaje JAVA

1.2.1 Generalidades de JAVA

1.2.2 Máquina Virtual de JAVA

1.2.3 Entorno de desarrollo y configuración

1.2.4 Tipos de datos soportados en JAVA

1.2.5 Operadores aritméticos, lógicos y relacionales

1.2.6 Conversiones de tipos de datos

1.3 Organización de un programa

1.3.1 Estructura general de un programa

1.3.2 Convenciones de la programación

1.3.3 Palabras reservadas

1.3.4 Estructura de una clase

1.3.5 Declaración de objetos y constructores

Unidad 2. Métodos y estructuras de control

2.1 Generalidades de los métodos

2.1.1 Declaración y ámbito de variables

2.1.2 Declaración de constantes

2.2 Métodos que no devuelven valores

2.2.1 Características

2.2.2 Llamada de métodos

2.3 Métodos que devuelven valores

2.3.1 Recepción de parámetros

2.3.2 Retorno de parámetros

2.3.3 Paso de parámetros

2.3.4 Llamada de métodos

2.4 Estructuras de control selectivas

2.4.1 If – else

2.4.2 If anidados

2.4.3 Switch - case

2.5 Estructuras de control cíclicas

2.5.1 While

2.5.2 Do – While

2.5.3 For

Unidad 3. Características de POO y excepciones



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

Para el desarrollo de la presente asignatura se trabajará mediante el Aprendizaje Basado

en Resolución de Problemas; ya que en esta materia se debe aprender a enfrentar

problemas dados y ofrecer una solución a estos, de modo que primero se plantea el

problema, después el alumno identificará los requerimientos de información para lograr

solucionar el problema planteado.

Tomando en cuenta que en esta materia se deben generar aplicaciones de software se ha

planteado al menos un ejercicio por cada unidad temática ya que es importante que, ante

un problema dado se analice la información con la que se cuenta, y en base a esto se

logre dar una solución mediante software para resolver la problemática planteada en el

ejercicio, de manera que con las habilidades que se forjarán en cada una de las unidades

se logre el aprendizaje orientado a la generación de aplicaciones de software.



Tipo de actividades en el aula virtual: Foros, Wikis, Bases de Datos,

Autoevaluaciones.

Actividades de estudio independiente: lecturas, tareas, creación y ejecución de

programas.

En cuanto a la evaluación de las actividades y evidencias, el facilitador es quien debe

revisar los entregables realizados y retroalimentarlos de manera clara y concisa;

informando sobre el avance que se haya logrado, pero también tomando en cuenta los

errores que se cometan como parte del aprendizaje para que se eviten.

h. Evaluación

En el marco del Programa ESAD, la evaluación se conceptualiza como un proceso

participativo, sistemático y ordenado que inicia desde el momento en que el estudiante

ingresa al aula virtual. Por lo que se le considera desde un enfoque integral y continuo.

Por lo anterior, para aprobar la asignatura, se espera la participación responsable y activa

del estudiante así como una comunicación estrecha con su facilitador para que pueda

evaluar objetivamente su desempeño. Para lo cual es necesaria la recolección de

evidencias que permitan apreciar el proceso de aprendizaje de contenidos: declarativos,

procedimentales y actitudinales.

En este contexto la evaluación es parte del proceso de aprendizaje, en el que la

retroalimentación permanente es fundamental para promover el aprendizaje significativo y

reconocer el esfuerzo. Es requisito indispensable la entrega oportuna de cada una de las

tareas, actividades y evidencias así como la participación en foros y demás actividades

programadas en cada una de las unidades, y conforme a las indicaciones dadas. La

calificación se asignará de acuerdo con la rúbrica establecida para cada actividad, por lo

que es importante que el estudiante la revise antes realizarla.

A continuación presentamos el esquema general de evaluación.

ESQUEMA DE EVALUACIÓN

Evaluación

continua

Interacciones individuales y

colaborativas 10%

Tareas 30%

E-portafolio. 50% Evidencias 40%

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 2: Programa en JAVA. 6 Realizar un programa que solicite un número, si este es

par, que calcule su factorial, si es impar, que muestre ese mismo número de elementos de

la serie de Fibonacci, utilizando métodos que devuelven valor y que no devuelven.

Unidad 3: Programa en JAVA. Dada una serie de clases abstractas e interfaces

desarrollar un programa que los implemente utilizando excepciones.

Unidad 4: Programar una aplicación que muestre en un menú todos los programas vistos

en el curso.

Por otra parte la forma de evaluación será según lo indicado a continuación:

o Excelente: 100

o Bien: 80

o Regular: 60

o Insuficiente: 50

i. Fuentes de consulta

Bibliografía básica

Devis, R. (1993). C++/OOP: un enfoque práctico. Madrid, España: Editorial

Paraninfo. Recuperado el 1 de marzo de 2011, de:

http://www.a4devis.com/articulos/libros/Programaci%C3%B3n%20Orientada-a-

Objetos%20en%20C++.pdf

Joyanes, L. y Fernández, M. (2001) Java 2: manual de programación. España:

McGrawHill Interamericana de España SL.

Zukowski. J. (1997) The Java AWT Reference (Java Series), version 1.2. O'Reilly

& Associates. Recuperado el 1 de marzo de 2011, de:

http://oreilly.com/openbook/javawt/book/index.html

http://www.a4devis.com/articulos/libros/Programaci%C3%B3n%20Orientada-a-%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20Objetos%20en%20C++.pdf

http://www.a4devis.com/articulos/libros/Programaci%C3%B3n%20Orientada-a-%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20Objetos%20en%20C++.pdf




Bibliografía complementaria

Flanagan, D. (2005) Java in a NutShell. USA: O'Reilly & Associates.

Joyanes, L. (2001) OLC - Programación en C++. Serie Schaum, Capítulo 1:

Programación orientada a objetos versus programación estructurada: C++ y

algoritmos. España: McGrawHill Interamericana de España SL. Recuperado el 1

de marzo del 2011, de:

http://www.mcgraw-hill.es/bcv/guide/capitulo/8448146433.pdf




II. Desarrollo de contenidos por unidad

a. Unidad 1. Introducción a JAVA

Presentación de la unidad

En esta 1ª unidad de la materia Programación Orientada a Objetos I (POO I), se

aprenderá el concepto de la programación orientada a objetos y la descripción de los

elementos que la integran así como del lenguaje a implementar, el cual será JAVA, sus

características y la estructura de un programa.

Propósitos de la unidad

En esta unidad el estudiante logrará:

Distinguir entre programación orientada a objetos y programación estructurada.

Reconocer las características de la programación orientada a objetos.

Determinar las características y especificaciones de la programación en JAVA.

Identificar la organización de un programa en JAVA.

Desarrollar programas modulares.

Competencia específica

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.

Actividad 1. Presentación

Antes de comenzar el estudio de la asignatura, te invitamos a participar en un foro de

discusión general, creado para que comentes cualquier asunto relacionado con la

asignatura; en él, conocerás a tus compañeros de grupo y entre todos podrán apoyarse

para resolver dudas, inquietudes, externar comentarios, etcétera.



Para comenzar tu participación, ingresa a la Actividad 1.Presentación en el aula.

1.1. Características de la Programación Orientada a Objetos

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

De acuerdo a Joyanes, la abstracción es:

“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:

El polimorfismo es la propiedad de una operación de ser interpretada

exclusivamente por el objeto al que corresponde.

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.

Esta propiedad permite intercambiar objetos en una operación; retomando el ejemplo de

los reproductores puedes cambiar la carcasa por una más moderna o llamativa sin que el

funcionamiento interno se vea afectado.

1.1.4. Herencia

La herencia en el paradigma de la POO es un mecanismo que se utiliza para efectuar la

reutilización del software, de modo tal que los programadores pueden crear clases nuevas

a partir de clases ya existentes, tomándolas como base y creando una jerarquía de

clases, de esta manera no se tiene que rehacer todo el código de una clase.



Si se ve de manera más sencilla, la herencia en programación funciona de manera similar

a la herencia familiar, por ejemplo, si un papá tiene un hijo que se parece mucho

físicamente a él, entonces ambos comparten ciertas características, podemos decir

entonces que el papá le heredó sus características físicas al hijo.

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.

1.1.5. Programación orientada a objetos vs estructurada

Desde la concepción de la programación estructurada (y por su misma etimología) se ha

entendido de manera que se debe realizar de manera secuencial y haciendo el diseño

como lo marcan los cánones: de arriba a abajo (Top-Down) o de abajo a arriba (Bottom-

Up). De esta manera se comienza a pensar y escribir una secuencia de instrucciones que

deberán resolver el problema que se presenta y para el cual se escribe el programa

deseado. Cuando la complejidad misma inherente al problema crece, por cualquiera que

sea la razón, esta concepción deja de ser útil e inevitablemente se debe voltear la mirada

a otro paradigma de programación, que, no importando cuán grande y complejo se torne

la solución del problema, sea capaz de manejarlo e implementarlo. Se está hablando de la

Programación Orientada a Objetos (POO).

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



acciones en programación estructurada y POO sea igual, no lo es; la principal diferencia

estriba en que para la POO estas operaciones (métodos) conforman al objeto en sí, son

parte de él y en la programación estructurada son funciones aisladas que no tienen

vínculo alguno, más que desde donde son llamadas.

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.

Sin embargo los problemas no son inherentes a la programación estructurada, sólo es

mala aplicación de sus conceptos a la resolución de problemas, se listan a continuación

una serie de malas prácticas sobre la programación estructurada:

No se sigue completamente la forma en que trabaja el cerebro del ser humano, ya

que éste capta la realidad en base a “objetos” y sus propiedades (atributos) y las

cosas que puede hacer o que se hacen sobre él (método).

Dificultad para extender los programas existentes a las nuevas necesidades

No se centra el modelo en el mantenimiento, se centra en la generación de

soluciones repetitivas para los mismos problemas.

Las entidades funcionales no se sincronizan o lo hacen de manera difícil y

tortuosa.

Muchos lenguajes de programación que se dicen orientados a objetos aun aceptan gran

parte del paradigma de la programación estructurada, dando pie a hacer una

programación mezclada y llevando lo peor de ambos mundos, se recomienda evitar esto.

Actividad 2. Diferencias entre Programación estructurada y POO

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:



1. Previo a tu ingreso al foro, identifica las diferencias entre análisis, programación

estructurada y programación orientada a objetos.

2. Ingresa al foro correspondiente a esta actividad y genera una nueva entrada en

la que comentes las diferencias identificadas.

3. Contribuye con algún comentario a por lo menos dos compañeros(as) sobre su

discernimiento del tema.

4. Con base en las aportaciones de tus compañeros(as), reelabora las diferencias

entre, la programación estructurada y de la programación Orientada a Objetos y

publícalas como conclusión del foro.

Actividad 3. Características de JAVA

Esta actividad tiene como finalidad que a partir de un ejercicio colaborativo se identifiquen las características de JAVA. Para iniciar, realiza lo siguiente:

1. Investiga respecto a las características y aplicaciones de JAVA.

2. Ingresa a la wiki con el nombre de esta actividad e integra tu participación

respecto a las características de JAVA.

*Recuerda incluir las fuentes de consulta utilizadas.

3. Revisa las aportaciones de tus compañeros y contribuye en la elaboración de las

conclusiones del tema.

1.2. Características del lenguaje JAVA

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.

1.2.1. Generalidades de JAVA

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.

Sencillo. Java es un lenguaje simple. La mayoría de los lenguajes de programación

orientados a objetos no son ni cercanamente sencillos ni fáciles de utilizar o comprender,

pero Java es un poco más fácil que C++, que se consideraba como el lenguaje de

programación más popular hasta la implementación de Java. Java ha puesto simplicidad

en la programación en comparación con C++, incorporando características medulares de

C++ y eliminando algunas de éstas que hacen de C++ un lenguaje difícil y complicado.

Haciendo referencia a la facilidad de Java y su sencillez, se dice que es simple porque

consta sólo de tres tipos de datos primitivos: números, boolean y arrays. Todo en Java en

una clase. Por ejemplo, las cadenas son objetos verdaderos y no arrays de caracteres.

Otros conceptos que hacen la programación en C++ más complicada son los punteros y

la herencia múltiple. Java elimina los punteros y reemplaza la herencia múltiple en C++

con una estructura única denominada interfaz (Joyanes y Fernández, 2001).

La utilización de asignación de memoria y recolección de basura automáticas son otro

aspecto que abona a la sencillez de Java sobre otros lenguajes, por ejemplo con el ya

citado C++, donde el programador debe realizar estas tareas de forma manual, con los

posibles errores que esto puede conllevar. Otra facilidad que proporciona Java es la

elegancia de su sintaxis que hacen más fácil la lectura (comprensión) y escritura de

programas.



Orientado a Objetos. La programación orientada a objetos permite de una manera muy

sencilla modelar el mundo real o los problemas que en él se presenten y necesiten ser

resueltos mediante programas, cualquier cosa del mundo real puede ser modelada como

un objeto. Un libro es un objeto, un automóvil es un objeto e incluso un préstamo o una

tarjeta de crédito es un objeto. Un programa en Java se denomina orientado a objetos

debido a que la programación en Java se centra en la creación, manipulación y

construcción de objetos (Joyanes y Fernández, 2001).

Java es un lenguaje de programación orientado a objetos. Lo que significa que el trabajo

real sobre la construcción de los programas se centra en un gran porcentaje (por no decir

la totalidad) en los datos de la aplicación y los métodos que manipulan estos datos, en

lugar de pensar estrictamente en términos de los procedimientos. Si se está

acostumbrado a utilizar la programación basada en procedimientos (por ejemplo con el

lenguaje C o BASIC), es posible que sea necesario cambiar la forma de diseñar los

programas o aplicaciones cuando se utiliza Java. Una vez que se experimente lo

poderoso que resulta este paradigma (orientado a objetos), pronto se ajustará a él.

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.

Interpretado. Java es un lenguaje interpretado y necesita un intérprete para ejecutar

programas. El compilador de Java genera bytecode para la Máquina Virtual de Java

(JVM), en lugar de compilar al código nativo de la máquina donde se ejecutará. El

bytecode es independiente de la plataforma y se puede hacer uso de él en cualquier

máquina (no necesariamente una computadora) que tenga un intérprete de Java.



En un entorno donde el lenguaje de programación es interpretado, la fase estándar de

“enlace” casi se vería desvanecida. Si java cuenta con esta fase como un todo, es sólo

porque el proceso de cargar clases nuevas en el ambiente de ejecución se hace

precisamente en esta fase, que es un proceso incremental y mucho más ligero que se

produce en tiempo de ejecución. Contrastando con el ciclo más lento y complicado de

compilar-enlazar-ejecutar de lenguajes como C o C++. Los programas Java no necesitan

ser recompilados en una máquina destino. Se compilan en un lenguaje ensamblador para

una máquina imaginaria, denominada máquina virtual (Joyanes y Fernández, 2001).

Arquitectura Neutral y Portable. Debido a que el lenguaje Java se compila en un

formato de arquitectura propia o mejor dicho neutra llamada bytecode, un programa en

Java puede ejecutarse en cualquier sistema, siempre y cuando éste tenga una

implementación de la JVM y esta es la característica tal vez más notable que tenga Java.

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.

La misma definición de bytecode hace que Java sea multiplataforma y no tenga la

necesidad de complicados temas al portar la aplicación entre dispositivos como tipos de

datos y su longitud, características y capacidades aritméticas; caso contrario, por ejemplo,

del lenguaje C donde un tipo int puede ser de 16, 32 ó 64 bits dependiendo de la

plataforma de compilación y ejecución. Los programadores necesitan hacer un solo

esfuerzo por terminar sus asignaciones, esto se puede lograr apegándose al slogan que

hizo tan famoso Sun: “Write Once, Run Anywhere” (Escribe una vez, ejecuta donde sea).

Dinámico y Distribuido. Java es un lenguaje dinámico. Cualquier clase construida en

Java puede cargarse en cualquier momento dentro del ejecutor en cualquier momento.

Así, si es cargada dinámicamente puede instanciarse de igual manera. Las clases en

Java con representadas por la palabra reservada class se puede obtener información en

cualquier momento sobre ellas mediante el run-time.



En cualquier instante de la ejecución Java puede ampliar sus capacidades mediante el

enlace de clases que esté ubicadas en la máquina residente, en servidores remotos o

cualquier sitio de la red (intranet/internet). Caso contrario de lenguajes como C++ que

hacen esto al momento de la compilación, después ya no se puede. Se puede extender

libremente métodos y atributos de una clase sin afectar la ejecución corriente, las

capacidades descritas se encuentran dentro del API Reflections.

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).

Seguro. Uno de los aspectos más sobresalientes de Java es el de ser un lenguaje

seguro, lo que es especialmente interesante debido a la naturaleza de la distribución de

aplicaciones en Java. Sin un aseguramiento el usuario no estará tranquilo de bajar y

ejecutar código en su computadora desde internet o cualquier otra fuente. Java fue

diseñado con la seguridad como punto principal y tiene disponibles muchas capas que

gestionan la seguridad de la aplicación que se escribe, bloqueando al programador si

intenta distribuir código malicioso escrito en lenguaje Java.

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.

Aunado a lo anterior y haciendo referencia a la facilidad de Java, programar multihilo en

Java es muy fácil, ya que si se ha tratado trabajar con hilos en C o C++ se notará la

enorme dificultad que esto representa. La clase Thread da el soporte, la facilidad y los

métodos para iniciar y terminar la ejecución y hacer uso de los hilos, que a su vez se

encuentra contenida en el nombre de espacio java.lang. La sintaxis del lenguaje Java de

igual manera tiene soporte directo sobre la palabra reservada synchronized la cual hace

extremadamente fácil para marcar secciones de código o métodos completos que

necesitan ser ejecutados de uno en uno o dicho de mejor manera “sincronizados”.



1.2.2. Máquina virtual de JAVA

¿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.

En otras palabras, la JVM es la piedra angular del lenguaje de programación Java. Es el

componente que hace que Java tenga su particular y muy mencionada característica

multiplataforma, generar un código compilado tan compacto y la capacidad del lenguaje

de proteger a sus usuarios de código malicioso.

La JVM es una máquina de computación de tipo abstracto. Emulando a una máquina de

componentes reales, tiene un conjunto de instrucciones y utiliza diversas áreas de

memoria asignada para ella. La implementación del primer prototipo de la JVM, hecho por

Sun Microsystems, emulando todo su conjunto de instrucciones fue hecho sobre un

hardware muy específico, lo que hoy se podría conocer como los modernos Personal

Digital Assistant (PDA). Las versiones actuales de la JVM están disponibles para muchas

(casi todas) las plataformas de computación más populares. Debe entenderse sin

embargo que, la JVM no asume una tecnología específica o particular, esto es lo que la

vuelve multiplataforma. Además no es de por sí interpretada, y que sólo pueda funcionar

de esta manera, de hecho es capaz de generar código nativo de la plataforma específica

e incluso aceptar como parámetro de entrada, en lugar del bytecode, código objeto

compilado, por ejemplo funciones nativas de C. De igual manera puede implementarse en

sistemas embebidos o directamente en el procesador.

¿Cómo funciona la JVM?

La JVM no sabe nada del lenguaje de programación Java, no es de su interés, porque un

compilador ya se encargó antes de ese proceso, sólo le interesa un formato específico de

archivo, el formato de archivo de clase o entendido de otra manera, el bytecode más una

tabla de símbolos e información complementaria.

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



característica multiplataforma que imprime la JVM al lenguaje Java, los programadores de

otros lenguajes de programación han recurrido a ella como vehículo de entrega

(ejecución) de estos lenguajes, lo que nos da a entender que su capacidad

multiplataforma puede extender la implementación de casi cualquier lenguaje que cumpla

con sus reglas para ser multiplataforma.

La funcionalidad completa, a manera de esquema se presenta en la siguiente figura:

Figura 1.1. Funcionalidad de la Máquina Virtual de JAVA (Zukowski, 1997).

1.2.3. Entorno de desarrollo y configuración

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.

Para cualquier (o casi cualquier) lenguaje de programación, afortunadamente incluido

Java, hay una serie de herramientas que facilitan enormemente el poder producir

aplicaciones completas y sólo requiriendo el esfuerzo del programador en las partes

importantes del sistema, dejando a estas herramientas la “preocupación” de las cosas



menos importantes. Para ejemplificar lo anterior se deberá entender de la siguiente

manera:

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.

Componentes del IDE

Los elementos básicos de un IDE, pero no limitado a ellos, son:



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.

Configuración del IDE

Cuando se hace la instalación de un IDE la configuración que trae por defecto es la

habitual y será suficiente para poder comenzar a trabajar sobre él, la personalización que

se haga de las distintas herramientas con las que cuenta dependerá del gusto de cada

programador. Las posibles configuraciones que se hacen sobre el IDE van desde cosas

tan simples como el tipo de letra y su tamaño para mostrar el código fuente, hasta



opciones muy avanzadas donde consumimos servicios web de determinado sitio de

internet.

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).

1.2.4. Tipos de datos soportados en JAVA

Tipo de dato Tamaño en bits Rango de valores Descripción

Números enteros

Byte 8-bit complemento

a 2 -128 a 127 Entero de un byte

Short 16-bit

complemento a 2 -32,768 a 32,767 Entero corto

Int 32-bit

complemento a 2

-2,147,483,648 a

2,147,483,647 Entero

Long 64-bit

complemento a 2

-

9,223,372,036,854,775,808L

a

9,223,372,036,854,775,807L

Entero largo

Números reales

Float 32-bit IEEE 754 +/- 3.4E+38F Coma flotante con

precisión simple

Doublé 64-bit IEEE 754 +/- 1.8E+308 Coma flotante con

precisión doble

Otros tipos

Char 16-bit Carácter Conjunto de caracteres

Unicode ISO

Un solo carácter

Booleano true o false Verdadero o falo Un valor booleano

String Variable Conjunto de caracteres Cadena de

caracteres.

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)

{

int x; // un dato declarado pero sin valor inicial.

boolean isReal=true; // Los nombres son sensibles a

// mayúsculas y minúsculas,

// deben empezar por una letra y

// pueden contener números,_,$

byte a = 121; // Deben ser inferiores a 126

short b = -10000; // Deben ser inferiores a 25000

int c = 100000; // Deben ser inferiores a 2100 mill.

long d = 999999999999L; // Deben poner L al final

float e = 234.99F; // Deben ser < 3E38; F al final

double f = 55E100;

char charValue= '4'; // char '4' no es el entero 4

//Las cadenas (strings) son objetos, no primitivos.

//Ejemplo:

String institucion = “esad”;

}

}



Actividad 4. Tipos de datos

Durante esta actividad identificarás la aplicación de los diferentes tipos de datos soportados por JAVA, en relación con diferentes datos programables.

1. En un archivo de texto, copia la Tabla 1 y analiza los datos que incluye.

2. Identifica el tipo de datos que se requieren para programar como variable cada

dato brindado.

3. Guarda la actividad con el nombre POO_U1_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.

4. Envía el archivo a tu Facilitador(a) mediante la sección Tareas para recibir

retroalimentación.

Tabla 1

Datos de

una casa

#_pisos #_cuartos #_ventanas #_baños Fondo

Tipo

Datos de

un auto

#_puertas #_cilindros #_hp colorCarroceria #_placas

Tipo

Datos de

una

factura

#_folio total nombreCliente nombreEmpresa Iva

Tipo

Datos de

un

zapato

punto material Tacón color #_estilo

Tipo

Datos de

una

computa

dora

Marca procesador Memoria pantalla discoDuro

Tipo



1.2.5. Operadores aritméticos, lógicos y relacionales

En el entorno Java, la palabra operador se le llama a un símbolo específico que realiza

una “operación” determinada entre dos o más valores, se puede entender con el

procedimiento habitual que utilizamos para sumar, por ejemplo:

3+5=8

El operador de suma (representado por el símbolo +) está actuando sobre el 3 y el 5 para

producir el 8. Como se puede ver, la evaluación de los operadores y sus operandos

siempre devuelve un valor, pues es la parte que define a las operaciones.

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 Significado Asociatividad

++ Incremento Derecha a izquierda

-- Decremento Derecha a izquierda

+ Unario + (símbolo positivo) Derecha a izquierda

- Unario – (símbolo negativo) Derecha a izquierda

* Multiplicación Izquierda a derecha

/ División Izquierda a derecha

% Resto (módulo) Izquierda a derecha

+ Suma Izquierda a derecha

- Resta Izquierda a derecha

Utilización de operadores aritméticos

public class opAritmeticos

{

public static void main(String[] args)

{

int j, k, m;

int d= 123;

j= d--; // j vale 122 y d vale 123

System.out.println("j= " + j);



k= ++d; // k vale 124 y d vale 124

System.out.println("k= " + k);

m= --d; // m vale 123 y d vale 123

System.out.println("m= " + m);

m= k % j; // operador Resto para los tipos int

// k=124 y j=122, por tanto,

m= 2 System.out.println("m= " + m);

j= 5; k= 3; m= j/k; // División entera: m= 1

System.out.println("m= " + m);

System.exit(0);

}

}

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

double c= 0.0, b= 3.0;

if (c != 0.0 && b/c > 5.0){

System.out.println(“se cumple la condición solicitada”);

}

Operadores de asignación

Se deberá en primer término, hacer la distinción entre la acción de asignación y el

operador de comparación (igualdad), aunque aparentemente al inicio pueda resultar

confuso por el parecido entre ambos, lo que distingue uno de otro es precisamente el

concepto que cada uno de ellos representa y la forma de presentarse, así pues:

El operador “=” no es lo mismo que el operador “==”

El operador básico al utilizar la asignación es “=”, que se utiliza para asignar un valor a

otro. Como sigue:



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:

Operador Uso Equivalente a

+= a += b a = a + b

-= a -= b a = a – b

*= a *= b a = a * b

/= a /= b a = a / b

%= a %= b a = a % b

&= a &= b a = a & b

Operadores de bit

Dan la posibilidad de manipular los bits de los datos, especialmente el desplazamiento.

Operador Uso Operación

>> a >> b Desplaza los bits de “a” a la

derecha “b” veces

<< a << b Desplaza los bits de “a” a la

izquierda “b” veces

>>> a >>> b Desplaza los bits de “a” a la

derecha “b” veces

(omitiendo el signo)

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

El número entero 25 está representado por el número 11001 en notación binaria, al

aplicarle el operador de desplazamiento el número 11001 ahora se convertirá en 110 o el

número entero 6. El lector debe notar que los bits que se desplazan a la derecha se

pierden al efectuar esta operación.

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:

1. En un archivo de texto, copia las operaciones dadas en la Tabla 2.

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.

3. Guarda la actividad con el nombre POO_U1_A4_XXYZ, sustituye las XX por las



4. Envía el archivo a tu Facilitador(a) para recibir retroalimentación.

Tabla 2



# Operación

Operadores

encontrados

Tipo de

operadores Resultado

1 (3 + (2 *3) -12) / 3

2

P: Verdadero

Q: Falso

P y Q

3 10> 5 >6

4 (((200 +305)/56)*30)<12

5

P: 3+9<10

Q:30 -64 > - 40

P o Q

1.2.6. Conversión de tipos de datos

La conversión de tipos de datos (conocida también como casting) es pasar un objeto de

un tipo en otro. Se puede ejemplificar de manera clara pensando en que si tienes un

pequeño programa que tiene dos números enteros, el resultado de la división se

almacena también en un entero, y quieres dividirlos, el resultado se truncará a un entero

también, pues solo estás tomando en cuenta la capacidad de almacenamiento de los

enteros. El código y resultado sería como se muestra a continuación:

public class EjamploCast {

public static void main(String[] args) {

int di=33;

int dv=5;

int c=di/dv;

System.out.print(c+ "\n");

}

}

Como vemos, el resultado se truncó hasta el valor entero.



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.

En este caso el resultado si tiene los decimales que necesitamos.

En un ejemplo más amplio si se tienen3 clases A, B y C que se pueden almacenar en un

arreglo de la siguiente manera:

Object [] array = new Object[3];

array[0] = new A();

array[1] = new B();

array[2] = new C();

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();

Obviamente no puedes convertir cualquier tipo a cualquier tipo. Si intentas convertir

array[0] a B, te dará error, salvo que A herede de B. Pero estos casos más complejos los

trataremos más adelante.

1.3. Organización de un programa

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.

1.3.1. Estructura General

La estructura general se describe a continuación:

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 {


System.out.println("Hola, ");

System.out.println("bienvenido (a)");



System.out.println("a la programación en Java");

}

}

Para comprender mejor lo que hace el programa y las partes que lo conforman se

explicará. Bienvenida es el nombre de la clase principal y por tanto, del archivo que

contiene el código fuente (por convención de Java, el archivo donde se guarda el código

fuente deberá tener el mismo nombre de la clase principal). Como ya se ha explicado

antes, todos los programas en Java tienen un método principal de entrada conocido como

main que a su vez contiene (encierra) un conjunto de sentencias que significan las

instrucciones que deberá ejecutar el programa, este conjunto de instrucciones o bloque de

instrucciones en Java se indican con la utilización de llaves { }. En el programa contenido

en la clase bienvenida el bloque se compone sólo de tres instrucciones de impresión a

pantalla.

Utilización de comentarios. Desde el surgimiento de los lenguajes de programación,

junto con ellos, de igual manera nació la necesidad de hacer anotaciones sobre lo que

hace tal instrucción, un método completo o inclusive el programa entero. Esta necesidad

se resolvió con la introducción del soporte de comentarios (notas) dentro del mismo

código fuente que se pueden emplear de distintas formas, por ejemplo recordar para qué

se usó una variable específica, para documentar los valores de retorno de un método,

entre muchos otros. Los comentarios que se utilizan en Java son del mismo estilo a los

empleados en C/C++, así el compilador al comenzar a hacer su trabajo ignora por

completo lo que esté entre estos comentarios ya que no forman parte del código del

programa, sólo son líneas de carácter informativo para el programador humano. Hay

comentarios de una línea y de varias líneas, por ejemplo:

// 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 */

El lector debe notar que la forma de comenzar el comentario es ligeramente diferente al

comentario multilínea, ya que ahora se incluye un asterisco más, para quedar como “/**”.

La forma de terminarlo es la misma.

Como sugerencia sobre los comentarios se debe hacer notar que, la necesidad de escribir

comentarios es para la aclaración de ciertas partes del código que no estén muy claras,

por tanto si se exagera en el número de comentarios se entenderá que el código no es

claro y se deberá considerar la necesidad de reescribirlo para hacerlo comprensible.

Identificadores

Se entenderá al identificador como aquella palabra o nombre que el programador le

asigna a sus propias variables, métodos e inclusive nombres de clases y tiene un ámbito

de aplicación e injerencia sólo dentro del código fuente, escrito por el programador

humano porque una vez que pasa por el proceso de compilación, el compilador genera

sus propios identificadores más acorde y más óptimos para su propia interpretación

dentro del bytecode. Como regla general del lenguaje Java se debe definir un identificador

antes de ser utilizado. Siguiendo las reglas que Java establece para la creación de

identificadores se deberá apegar a lo siguiente:

Un identificador comienza por una letra o utilizando el carácter de guión bajo (_) e

inclusive utilizando el símbolo de pesos ($) aunque esto último no se recomienda

ya que, como se explicó, el compilador lo utiliza de forma muy frecuente para

formar sus propios identificadores.

Se pueden utilizar a continuación números (0 al 9). Pero no dejar espacios en

blanco, signo de interrogación (?) o símbolo de porcentaje (%).

Un identificador puede contener la longitud que el programador asigne

arbitrariamente o considere necesario para dejar perfectamente claro el propósito

del identificador y qué tipo de dato alojará.

En Java, al ser sensible al contexto, se distinguen los caracteres en mayúscula y

minúscula. Así promedio, Promedio y PROMEDIO serán locaciones de memoria

completamente diferentes.

No se puede repetir el mismo identificador para dos variables o cualquier otra parte

del código (nombres de métodos o clases por ejemplo) ya que como se ha

mencionado, los identificadores hacen precisamente eso, identifican de manera

única a cada parte del código.

Aunque la escritura de identificadores no está normalizada en Java, se puede

apegar a las siguientes recomendaciones:



Identificadores autoexplicativos, para guiar al usuario (de cualquier tipo) a entender

la utilización de dicho identificador sin la necesidad de utilizar comentarios. Por

ejemplo para alojar el resultado del promedio de n números enteros se sugiere

utilizar el identificador resultadoPromedio o resAvg.

Si el identificador está compuesto por dos o más palabras, éstas se agrupan, la

primera de ellas se escribe totalmente en minúscula y la primera letra de las

subsecuentes se escribe con mayúscula, por ejemplo:

resultadoPromedioCalificaciones o longitudMedida.

Como se mencionó se puede utilizar el símbolo de guión bajo (_) pero por

convención sólo se emplea al nombrar constantes, ya que estas (igual por

convención) deberán escribirse en letra mayúscula y dificulta la lectura y

separación de la misma, por ejemplo: VALOR_GENERAL_ANUAL.

1.3.2. Convenciones de la programación

Paquetes (Packages): El nombre de los paquetes deben ser sustantivos escritos

con minúsculas. package shipping.object

Clases (Classes): Los nombres de las clases deben ser sustantivos, mezclando

palabras, con la primera letra de cada palabra en mayúscula (capitalizada). class

AccountBook

Interfaces (Interfaces): El nombre de la interfaz debe ser capitalizado como los

nombres de las clases. interface Account

Métodos (Methods): Los métodos deben ser nombrados con verbos, mezclando

palabras, con la primera letra en minúscula. Dentro del nombre del método, la

primera letra de cada palabra capitalizada. balanceAccount()

Variables (Variables): Todas las variables deben ser combinaciones de palabras,

con la primera letra en minúscula. Las palabras son separadas por las letras

capitales. Moderar el uso de los guiones bajos, y no usar el signo de dólares ($)

porque tiene un significado especial dentro de las clases. currentCustomer

Las variables deben tener significados transparentes para exponer explícitamente

su uso al lector casual. Evitar usar simples caracteres (i, j, k) como variables

excepto para casos temporales como ciclos.

Constantes (Constants): Las constantes deben nombrarse totalmente en

mayúsculas, separando las palabras con guiones bajos. Las constantes tipo objeto

pueden usar una mezcla de letras en mayúsculas y minúsculas. HEAD_COUNT

MAXIMUN_SIZE.

Estructuras de Control (Control Structures): Usar Llaves ({ }) alrededor de las

sentencias, aun cuando sean sentencias sencillas, son parte de una estructura de

control, tales como un if-else o un ciclo for (estas estructuras se explicarán a fondo

en la siguiente unidad).



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.

1.3.3. Palabras reservadas

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:

Abstract Do implements protected Throw

Boolean Doublé import Public Throws

Break Else instanceof Rest Transient

Byte Extends Int return True

Case False interface Short Try

Catch Final long Static Void

Char Finally native strictftp Volatile

Class Float New Super While

const* For Null switch



continue goto* package synchronized

Default If private This

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.

También existen palabras reservadas de empleo específico para nombres de métodos y

éstas son:

Clone Equals finalize getClass hashCode

Notify notifyAll toString Wait

1.3.4. Estructura de una clase

Apegándose estrictamente a los lineamientos que genera la documentación de Java, una

clase deberá contener las siguientes partes:

Package: Es el apartado que contendrá la definición de directorios o jerarquía de

acceso a donde estará alojada la clase.

Import: Sentencia necesaria para poder “invocar” todos las paquetes necesarios

(contenidos en otros packages) para que nuestra aplicación funcione. Por ejemplo,

al tratar de utilizar una conexión hacia una base de datos, necesitaremos importar

los paquetes que me proporcionan la funcionalidad necesaria. Algunos paquetes

de Java se importan automáticamente, no es necesario hacer un import explícito,

como la librería java.lang

Class: Definición del nombre de clase. Se determina el nombre identificador que

contendrá la clase.

Variables de ámbito de clase: Se determinan las variables que se usarán en la

clase para guardar datos y hacer operaciones.

Constructor de la clase: El constructor es un tipo especial de método, que se

invoca automáticamente al hacer una instancia del objeto. Sirve para inicializar los

objetos, las variables o cualquier configuración inicial que necesite la clase para

funcionar. Se puede sobrecargar.

Métodos: Bloques de código que contienen las instrucciones y declaraciones que

ejecutará el programa.

Ejemplo Uso

package javaapplication1;

import javax.swing.*;

Paquete

import si se requiere



public class JavaApplication1 {

public JavaApplication1(){}


//instrucciones

}

}

declaración de la clase

constructor

declaración del método

cuerpo del método

cierre del método

cierre de la clase

1.3.5. Declaración de objetos y constructores

El elemento básico de la programación en Java es la clase. Una clase define métodos

(comportamiento) y atributos (forma) de un objeto.

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:

“Todo es un objeto: Considere un objeto una variable especial, no solamente

guarda datos, sino también se pueden hacer solicitudes a este objeto en sí. En

teoría, cualquier elemento en el problema espacial (real) (edificios, servicios,

automóviles, u otra entidad) puede ser representado como un objeto en un

programa.

Un programa es un conjunto de objetos, enviándose mensajes entre sí: para

realizar una solicitud a un objeto es necesario enviarle un mensaje.

Concretamente se puede pensar que un mensaje es una solicitud para llamar una

función que pertenece a cierto objeto.

Cada objeto tiene su memoria, conformada por otros objetos: en otras palabras,

es posible generar un tipo de objeto nuevo agrupando objetos existentes. De esta

manera se pueden armar estructuras complejas en un programa, escondidas

detrás de la simplicidad de objetos.

Todo objeto tiene su tipo: en este sentido tipo se refiere a clase, donde cada

objeto es una instancia de una clase en cuestión. La característica más importante

de una clase es el tipo de mensajes que pueden ser enviados a ella.

Todo objeto de un mismo tipo puede recibir los mismos mensajes: esto

implica que si un objeto es del tipo círculo, un objeto del tipo figura será capaz de

recibir mensajes de círculo, puesto que un círculo es una Figura. Este concepto

forma parte medular de todo lenguaje orientado a objetos y será explorado en una

sección específica de este curso.” (Zulowski, 1997: 1)

empleado Nombre de la clase de la cual se

instanciará el objeto



objetoE Nombre del objeto

= Asignación

New Palabra new para hacer la separación de

la memoria.

empleado() Invocación al constructor

=new empleado(); Cierre de la instanciación

Quedando la instrucción como sigue:

empleado objetoE=new empleado();

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(){}

Y se usan para poder crear instancias de la clase (objetos).

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.

Ingresa al aula para realizar la actividad.



Evidencia de aprendizaje. Programa en JAVA

Como parte de la evaluación, desarrollarás un programa básico para la solución de operaciones matemáticas simples en el que aplicarás los componentes de JAVA, que durante la unidad has revisado. Realiza lo siguiente:

1. En NetBeans crea un nuevo proyecto, y dentro de la clase Main crea un

programa, donde se definan dos números, se resten y se multipliquen, para

después mostrar el resultado en la pantalla.

2. Consulta la Escala de evaluación que se encuentra en la sección Material de

apoyo, para conocer los criterios con que será evaluado tu trabajo.

3. Guarda la evidencia con el nombre POO_U1_A5_XXYZ. Sustituye las XX por las



4. Envía la carpeta del proyecto a tu Facilitador(a) mediante la herramienta

Portafolio de evidencias para recibir retroalimentación.

*Recuerda que puedes volver a enviar tu archivo tomando en cuenta las

observaciones de tu Facilitador(a).

Autorreflexiones

Además de enviar tu trabajo de la Evidencia de aprendizaje, es importante que ingreses

al foro Preguntas de Autorreflexión y consultes las preguntas que tu Facilitador(a)

presente, a partir de ellas, debes elaborar tu Autorreflexión en un archivo de texto llamado

POO_U1_ATR_XXYZ. Posteriormente envía tu archivo mediante la herramienta

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.

Al final de la unidad también vimos la estructura de un programa, palabras reservadas,

estructura de una clase, declaración de objetos y constructores, cuyo propósito fue

proporcionarte un panorama general de programar.

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.

Para saber más

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

Devis, R. (1993). C++/OOP: un enfoque práctico. Madrid, España: Editorial

Paraninfo. Recuperado el 1 de marzo de 2011, de:

http://www.a4devis.com/articulos/libros/Programaci%C3%B3n%20Orientada-a-

Objetos%20en%20C++.pdf

Joyanes, L. (2001). OLC - Programación en C++. Serie Schaum, Capítulo 1:

Programación orientada a objetos versus programación estructurada: C++ y

http://netbeans.org/downloads/

http://www.a4devis.com/articulos/libros/Programaci%C3%B3n%20Orientada-a-Objetos%20en%20C++.pdf

http://www.a4devis.com/articulos/libros/Programaci%C3%B3n%20Orientada-a-Objetos%20en%20C++.pdf



algoritmos. España: McGrawHill Interamericana de España SL. Recuperado el 1

de marzo del 2011, de:


Joyanes, L. y Fernández, M. (2001). Java 2: manual de programación. España:

McGrawHill Interamericana de España SL.

Zukowski. J. (1997). The Java AWT Reference (Java Series), version 1.2. O'Reilly

& Associates. Recuperado el 1 de marzo de 2011, de:


Bibliografía complementaria

Flanagan, D. (2005). Java in a NutShell. USA: O'Reilly & Associates.





Unidad 2. Métodos y estructuras de control


En la unidad anterior se vieron temas introductorios para la programación OO, cuyos

temas fungieron como iniciación para comprender el uso y aplicación de la programación.

En esta unidad de POO I, aprenderás el concepto de los métodos y su utilización para

crear programas modulares, así como el manejo de las estructuras de control selectivas y

cíclicas. Todo esto se utilizará para que realices programas más completos y complejos

en la siguiente unidad sobre la aplicación de las características de POO y las

excepciones.

Propósito

En esta unidad lograrás:

o Describir las generalidades de los métodos.

o Distinguir los métodos que devuelven valores contra los que no devuelven.

o Manejar las estructuras de control selectivas y cíclicas.


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.

Consideraciones específicas de la unidad: actividades, requerimientos

de asignatura, etc.

Es muy importante que captures todos los programas de ejemplo, para que analices su

sintaxis y puedas comprender mejor los temas vistos.



2.1. Generalidades de los métodos

Cuando se está trabajando en el lenguaje de programación Java, la clase es el elemento

básico que lo conforma, pero a su vez la clase está conformada por varios sub-bloques de

código que la conforman. Estos sub-bloques se llaman métodos y agrupan de manera

más o menos ordenada a los algoritmos que conforman el cuerpo de nuestro programa o

aplicación.

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.

Además de lo anterior, podremos entender a los métodos como:

Un bloque de código que tiene un nombre,

Capaces de recibir parámetros o argumentos (opcionalmente, como ya se dijo),

Contienen sentencias que le permiten realizar la tarea para la cual fue creado y

Devuelven un valor de algún Tipo (recordar el tema de tipo de datos) conocido.

2.1.1. Declaración y ámbito de variables

Haciendo referencia al apartado de tipos de datos, se hablará ahora del concepto de

variable que se entenderá como una locación de memoria reservada para alojar un dato

que cambiará respecto al tiempo/espacio donde se ejecute la aplicación. Tienen asociado

un identificador y un tipo de dato que le da nombre (identificador) y qué guardaremos en

ella (tipo de dato); lo que es aplicable a Java y cualquier otro lenguaje de programación.

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:



Variables primitivas: sirven para almacenar datos numéricos, valores lógicos o

caracteres.

Variables referenciadas: asociadas a un objeto o son la instancia de una clase.

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

Cuando se habla de variables referenciadas o asociadas a un objeto, los bits representan

un identificador que permite acceder al valor de la variable, es decir nos da una referencia

al objeto, pero no es el objeto a la variable en sí. Visto de manera gráfica, pudiera quedar

como sigue:



Integer z=new Integer(100); //declaración de una variable de tipo objeto Integer, válido en

Java.

Se muestra a continuación algunos ejemplos de declaraciones de variables referentes a

Java, para los tipos de variables primitivas y las variables referenciadas o asociadas a un

objeto:

int a; // declaración de una variable 'a' de tipo entero

//su valor inicial (por definición) es 0.

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'.

referencia = new Nombre_Clase;

// En este tipo de variables la declaración no es suficiente se deberé crear

// un nuevo objeto de la clase 'Nombre_Clase', y es asignado a la variable

// 'referencia'. En el paso anterior se dijo que se crea el contenedor,

// en este paso se le asigna un valor (referencia al objeto) al contenedor.

referencia2 = referencia;



// Ahora también 'referencia2' tiene el mismo

// objeto a su cargo que '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:

public class AmbitoVariables{


if (true) {

int a=10; //Decalaración de la variable dentro del bloque que corresponde

// a la sentencia if (dentro del ámbito del if).

}

System.out.println(a); // Acceso a la variable fuera del ámbito donde

//fue declarada (fuera del bloque if, delimitado

//por llaves).

}

}

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.



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.

2.1.2. Declaración de constantes

Desde la concepción de la definición del lenguaje Java, no fueron consideradas las

constantes en su término más estricto, entendidas como un valor que no puede ser

alterado durante la ejecución de un programa y corresponde a una longitud fija en la

memoria de la computadora donde se ejecuta el programa.

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.

Figura 1 Figura 2



La siguiente declaración define la constante llamada PI cuyo valor está definido por el

número (3.1415927…).

static final float PI = 3.1415927; //Constante que representa el número PI

Como ya se dijo, si se intenta modificar el valor contenido en la variable identificada como

PI, se dará un error de compilación.

2.2. Métodos que no devuelven valores

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

El hecho de que un método regrese valores o no es opcional. Cuando un método no

retorna valores, se deberá modificar la definición de sus parámetros y quedará como

sigue:

void nombre_método([parámetros]){

sentencia1;

sentencia2;

sentenciaN;

}

En donde se deberá utilizar la palabra reservada void que le indica al compilador y al

método que su valor de retorno será “vacio”. Dentro del cuerpo de sus sentencias se

omite la sentencia return por no “regresar” valor alguno a donde fue llamado. Los

parámetros de igual manera son opcionales, aunque los paréntesis van por obligación.

2.2.2. Llamada de métodos

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.



Los métodos se invocan (llaman) por el nombre definido en su declaración y se deberá

pasar la lista de argumentos entre paréntesis. Por ejemplo, se definirá un método que

imprima a pantalla un mensaje para el usuario.

public void saludo_usuario(){

String cadena_Saludo = “Hola usuario, feliz viaje en Java”;

System.out.println(cadena_Saludo);

System.out.println(“Mensaje impreso desde un método”);

}

Cuando ya se ha definido el método y sus sentencias son las necesarias y adecuadas,

ahora si se hace una invocación a él, o mejor dicho, se invocan las sentencias que

conforman el cuerpo del método. Se hace de la siguiente manera:


saludo_usuario();

}

La salida será la siguiente:

Hola usuario, feliz viaje en Java

Mensaje impreso desde un método

2.3. Métodos que devuelven valores

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.



2.3.1. Recepción de parámetros

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.

Como ya se ha visto, en la declaración del método se escribe qué parámetros recibirá

dentro de los paréntesis separando cada uno de ellos por una coma, indicando el tipo de

cada uno de ellos y el identificador, se entenderá también que no hay límites en el número

de parámetros que se envían al método. Se presenta un ejemplo:

public int obtener_potencia(int base, int potencia){

…

}

Este método recibe dos parámetros de tipo entero, cuyos identificadores son base y

potencia.

2.3.2. Retorno de parámetros

Cuando el método de nuestro interés ya ha recibido (o consigue) los elementos

necesarios para poder realizar sus funciones, retornará el resultado de aplicar esas

funciones sobre los parámetros recibidos. Se deberá indicar en la declaración del método

qué tipo de dato retornará e indicarle en el cuerpo de sus sentencias la palabra reservada

return y aquí le indicaremos qué regresará. Se ilustra un ejemplo a continuación:

public int obtener_potencia(int base, int potencia){

int resultado = Math.pow(base, potencia);

return resultado;

}

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.



2.3.3. Paso de parámetros

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.


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).

2.3.4. Llamada de métodos

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.

Como ya se mencionó, al invocar un método simplemente se deberá escribir el nombre

del método que interesa utilizar, seguido de los parámetros que necesita el método

(fueron indicados en su declaración). Como ejemplo, se terminará de desarrollar el código

del método de la obtención de potencias.


int b = 3; //representando a la base

int p = 2; //representando a la potencia

int r_potencia // variable que recibirá el resultado desde el método

r_potencia = obtener_potencia(b,p);



System.out.println(“El resultado es: ”+r_potencia);

}

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);

Actividad 1. Tipos de variables y constantes

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.

1. Identifica las diferencias entre variables y constantes.

2. Ingresa al foro y genera una nueva entrada.

Actividad 2. Detección de errores

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.

1. En un archivo de texto, copia los datos dados.

2. Marca en rojo las líneas que contengan error.

3. Copia los métodos nuevamente 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;

}

Actividad 3. Sobre parámetros

Con el fin de distinguir los qué son los parámetros deberás elaborar una definición propia

de parámetros.

1. En un archivo de texto, escribe tu propia definición de parámetro, cuáles tipos

de parámetros existen, y cómo se deben utilizar dentro de un programa.



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.


2.4. Estructuras de control selectivas

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

La estructura de selección simple o if es aquella secuencia de un programa que se ve

afectada por una condición, si la condición es cumplida la secuencia del programa entrará

en el bloque de instrucciones de dicha estructura, de lo contrario la secuencia del

programa se “saltará” ese bloque de código y entrará al bloque de instrucciones del else

dado que la condición se cumplió. Esta estructura de control se conforma como sigue:

// Instrucciones previas a la condición

if( condición) {

Instrucciones a ejecutarse solo si la condición se cumplió.

}

else{

Instrucciones a ejecutarse si la condición NO se cumplió.

}

// Instrucciones a ejecutarse después de la condición

Las llaves se utilizan para agrupar las instrucciones que se han de ejecutar, si solo

quieres que se ejecute una instrucción puedes omitirlas.

Es importante mencionar que las instrucciones previas y posteriores al bloque if-else se

ejecutan de manera normal, se cumpla o no la condición, por lo que solo se altera la

secuencia del programa en ese bloque.

A continuación se muestra un ejemplo donde dada una calificación, se decide si la

calificación es aprobatoria o no y esto lo indica en un mensaje.



package ejemplos;

/**

* @author ESAD

*/

public class estructuraIF {


int calificacion=80;

if(calificacion> 70){

System.out.print("Aprobado");

}

else{

System.out.print("Reprobado");

}

System.out.print("esto se imprimirá se

cumpla o no la condición");

}

}

Define el paquete donde se encuentra

Indica el nombre del autor

Declara la clase llamada estructuraIF

Se declara el método main

Declaro la variable calificación

Establezco la condición de If

Se muestra a pantalla el resultado

Palabra reservada else

Se envía el mensaje a pantalla.

Se manda una impresión que se ejecutará

después de la estructura selectiva if –else.

2.4.2. If anidado

Esta estructura es un agrandamiento de la estructura anterior, ya que se pueden evaluar

diferentes condiciones ligadas. Por ejemplo, en el tema anterior solo queríamos que se

mostrara Aprobado o Reprobado según su calificación, pero ahora se quiere dar mayor

reconocimiento a los puntos obtenidos se realizaría de la siguiente manera:

package ejemplos;

/**

* @author ESAD

*/

public class estructuraIF {


int calificacion=90;

if(calificacion> 90 && calificacion <= 100){

System.out.print("Excelente");

}



else if(calificacion >80 && calificacion <= 90){

System.out.print("Muy Bien");

}

else if(calificacion >70 && calificacion <= 80){

System.out.print("Bien");

}

else if(calificacion < 70){

System.out.print("Muy mal");

}

}

}

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.

2.4.3. Switch - case

La estructura selectiva switch – case también es conocida como estructura de decisión

múltiple, en esta estructura se puede evaluar una misma expresión con, como su nombre

lo indica, múltiples opciones, pero en este caso no son condiciones, el switch evalúa si

una variable tiene un valor en específico, se muestra la estructura a continuación:

// Instrucciones previas a la condición

switch(expresion) {

case valor: instrucciones a ejecutarse;

break;

case valor: instrucciones a ejecutarse;

break;

default: instrucciones;

}

// Instrucciones a ejecutarse después de la condición



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.

Se muestra un ejemplo a continuación:

package ejemplos;

import javax.swing.JOptionPane;

/**

* @author ESAD

*/

public class ejemploSwitch {


int mes= Integer.parseInt(JOptionPane.showInputDialog("Cuál es el número del

mes"));

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.

Actividad 4. Programa de horóscopo

En NetBeans crea un programa que solicite al usuario el día y número de mes de su

nacimiento (en 2 variables diferentes) y muestra cuál es su signo zodiacal.

1. Entra a la wiki, y coloca ahí el programa realizado.

2. Revisar los mensajes de tu Facilitador(a), pues en caso de que el programa requiera

modificaciones tu Facilitador(a) te lo hará saber.

3. Realiza las modificaciones requeridas.



4. En caso de ser necesario, retroalimenta a tus compañeros para que modifiquen su programa.

2.5. Estructuras de control cíclicas

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).

Como regla general puede decirse que se utilizará:

Ciclo for cuando se conozca de antemano el número exacto de veces que ha de

repetirse un determinado bloque de instrucciones.

Ciclo do-while cuando no se conoce exactamente el número de veces que se

ejecutará el ciclo pero se sabe que por lo menos se ha de ejecutar una.

Ciclo while-do cuando es posible que no deba ejecutarse ninguna vez.

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;




/**

* @author ESAD

*/

public class ejemploWhile {


int n= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el 9"));

while(n != 9){

n= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el 9"));

}

}

}

En este ejemplo se pide al usuario ingresar el número 9, y el ciclo seguirá mientras no

ingresen el 9, en el momento en que la condición se deja de cumplir (precisamente al

ingresar el 9) el ciclo terminará y el programa también.

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);

Veamos el siguiente ejemplo:

package ejemplos;


/**

* @author ESAD

*/

public class ejemploDoWhile {


int n;

do{

n= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el 9"));

}

while(n != 9);



}

}

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:

for(inicio ; condición; incremento){

Bloque de instrucciones repetitivas

}

Inicio: se debe colocar un valor numérico donde comenzará el conteo de ejecuciones.

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;


/**

* @author ESAD

*/

public class ejemploFor {


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;


/**

* @author ESAD

*/

public class forAnidado {


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.

También se puede que el ciclo en lugar de ir de manera ascendente se realice de manera

descendente, para esto se debe tomar en cuenta que el inicio sea el último elemento, la

condición de paro el 0 y su incremento sea restar 1. Veamos el siguiente ejemplo, que es

el mismo que el ejemplo del for, pero ahora con un recorrido inverso.

package ejemplos;


/**

* @author ESAD

*/

public class ejemploFor2 {


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.

Actividad 5. Programa retorno de parámetros

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.

1. En NetBeans crea un nuevo proyecto.

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


apellido materno.

5. Envía la carpeta del proyecto a través de la sección de Base de Datos.

6. Revisa y comenta los trabajos de tus compañeros.

Autoevaluación


segunda unidad del curso, es necesario que resuelvas la autoevaluación de la unidad.





Evidencia de aprendizaje. Programa de series numéricas

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


apellido materno.

4. Envía la carpeta del proyecto a tu Facilitador(a) para recibir retroalimentación.

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.

Para saber más

Consulta la página oficial del lenguaje JAVA http://www.java.com/es/, donde podrás

encontrar manuales de referencia sobre los métodos, variables, estructuras de control

selectivas y de repetición.

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

http://www.java.com/es/



Unidad 3. Características de POO y Excepciones


En esta tercera unidad de Programación orientada a objetos I (POO I), aprenderás el

concepto de herencia y polimorfismo, así como el manejo de excepciones y la sintaxis

JAVA para su aplicación.

Propósito


1. Reconocer el concepto y uso de la herencia.

2. Reconocer el concepto y uso del polimorfismo.

3. Identificar el uso de las excepciones.

4. Identificar la sintaxis que JAVA ofrece para la implementación de estos temas.


Desarrollar programas modulares para para solucionar problemas diversos, aplicando la

herencia, el polimorfismo y el manejo de excepciones mediante la sintaxis que JAVA

ofrece para su implementación.

Consideraciones específicas de la unidad

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

En la definición del lenguaje Java se pensó en una de sus características más

sobresalientes: la 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.

3.1.1. Subclases y superclases

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.

Figura 3.1. Ejemplo de herencia

En un ejemplo más sobre la herencia de la superclase hacia la subclase debe imaginarse

que se cuenta con la clase circulo que es perfecta para hacer algunas operaciones y

abstracciones matemáticas y por supuesto nos servirá para más de un propósito y más de

una aplicación donde se utilice un círculo y las operaciones básicas inherentes a él. Para

algunas otras aplicaciones tal vez se precise manipular la clase círculo (con sus métodos

y atributos básicos) de otra manera y se necesite imprimirlo a pantalla. Para no modificar

por completo la clase círculo, que ya es usada por cientos de aplicativos más y resultarían

seriamente perjudicados, se creará una subclase de la clase padre circulo, se llamará



Dibujacirculo que tendrá la misma funcionalidad que su clase padre, más un método

añadido: imprimeCirculo.

Una manera de hacerlo es como sigue:

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.

Otra manera de poder resolver el problema es heredando (extendiendo) desde la clase

círculo a la subclase Dibujacirculo, como ya se había explicado. Se presenta a

continuación:

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.



3.1.2. Jerarquía de la herencia

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.

Figura 3.2 Ejemplo de la jerarquía de la herencia en la clase circulo

3.1.3. Clases y métodos abstractos

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

Esta capacidad, el polimorfismo, permite hacer diferentes implementaciones de los

mismos métodos abstractos. Es decir, se pueden realizar diferentes implementaciones de

un mismo método, para poder adaptarlo a las necesidades propias de cada clase.



3.2.1. Clases y métodos finales

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.

Esto se declara de la siguiente manera:

final class ClaseFinal {

//aquí va el cuerpo de la clase

}

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.

final public void metodoFinal(){

//...aquí va el cuerpo del método

}

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

Cuando se define o se pretende utilizar en Java una interface, en realidad se está

describiendo un comportamiento. De manera más general las interfases lucen un tanto

parecidas a una clase abstracta, sólo las diferencian el método de declaración:

1. En una clase abstracta se utiliza la palabra reservada abstract.

2. En una interface se utiliza la palabra reservada interface.

Tratando de entender la definición general de interfase, se dirá que es un sistema que

hace de puente para unir entidades no relacionadas entre sí. Cuando se sigue el proceso



normal de compilación, el compilador pone cada interface identificada en un archivo de

bytecode por separado como si fuera una clase normal, además como en las clases

abstractas, sólo tiene la definición de métodos pero no la implementación de ellos. En

esencia una interfase podría identificarse como lo mismo que una clase abstracta. El gran

diferenciador entre ellas y lo que justifica la existencia de las interfaces es porque pueden

emular el comportamiento de la herencia múltiple, que no lo soportan las clases

abstractas.

Una interfase se puede considerar una clase abstracta de hecho, y en ella se toma en

cuenta lo siguiente (Flanagan, 1997):

1. Todos los miembros son públicos.

2. Todos los métodos son abstractos.

3. Todos los campos son static y final.

Una interfase consta de dos elementos básicos:

1. La declaración que es donde se colocan los diversos atributos acerca de la

interface como el nombre o si se extiende de otra interfase, y

2. El cuerpo que contiene la declaración de los métodos y las constantes que

conforman la propia interfase.

3.2.3. Sobrecarga de métodos

Como se dijo en la definición de polimorfismo, cuando se sobrecarga un método se parte

del concepto de la clase abstracta.

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.



3.2.4. Sobrecarga de operadores

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:

1. Para realizar la operación de suma, cuando se acompaña de datos numéricos.

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.

Actividad 1. Herencia y polimorfismo

Esta actividad tiene como finalidad que reflexiones sobre el concepto y uso de la

herencia y el polimorfismo.

1. Identifica el concepto de herencia y polimorfismo.


Actividad 2. Cuadro sinóptico

El propósito de esta actividad es que identifiques los conceptos de herencia y

polimorfismo, así como su aplicación en JAVA.

1. En un archivo de texto, realiza el cuadro sinóptico de herencia y polimorfismo, así

como su aplicación en JAVA. Usa tu imaginación, puedes agregar imágenes y colores

tantos como sea necesario.



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.

Muchas clases de errores pueden provocar una excepción, desde un desbordamiento de

memoria o un disco duro estropeado, un intento de dividir por cero o intentar acceder a un

arreglo fuera de sus límites. Cuando esto ocurre, la máquina virtual Java crea un objeto

de la clase exception, se notifica el hecho al sistema de ejecución y se dice que se ha

lanzado una excepción.

3.1.1. Sentencia Try-catch

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.

3.1.2. Tipos de errores

Esencialmente cuando se refiere a los tipos de errores en el lenguaje Java se clasifican

dentro de dos tipos básicos:

1. Aquellas generadas por el lenguaje Java. Éstas se generan cuando hay errores de

ejecución, como al tratar de acceder a métodos de una referencia no asignada a

un objeto, división por cero, etc.

2. Aquellas no generadas por el lenguaje, sino incluidas por el programador, como al

tratar de leer un archivo o tratar de hacer conexión a una base de datos específica.

3.1.3. Jerarquía de las excepciones

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.

Actividad 3. Manejo de excepciones

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.

2. Envía el archivo a través de la sección Base de datos.



Autoevaluación


primera unidad del curso, es necesario que resuelvas la autoevaluación de la unidad.




Evidencia de aprendizaje. Implementación de clases abstractas

Como parte de la evaluación de esta unidad, realiza un programa cuyo propósito es

organizar los conceptos abordados a lo largo de la unidad.

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.

2. Consulta la Escala de evaluación.

3. Guardar la evidencia con el nombre POO1_U3_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.


* Recuerda que puedes volver a enviar tu archivo tomando en cuenta las observaciones

de tu Facilitador(a).



Autorreflexiones







Autorreflexiones.

Para saber más

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


En esta unidad de la materia Programación orientada a objetos I (POOI), aprenderás el

concepto arreglos, así como su manejo y recorrido.

En esta unidad de la materia de Programación orientada a objetos I (POOI), aprenderás

una de las estructuras de datos más importante y básica, que son los arreglos, conocerás

su concepto, así como su declaración, manipulación y recorrido. De esta manera

aprenderás a manejar varios datos unidos como un todo.

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


o Distinguir los arreglos unidimensionales y multidimensionales

o Manejar las operaciones básicas con arreglos


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.

4.1. Arreglos unidimensionales

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

En Java hay que declarar un array antes de poder utilizarlo. Y en la declaración es

necesario incluir el nombre del array y el tipo datos que se van a almacenar en él (Froufe,

2009: 35).

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:



Haciendo referencia al tema presentado antes “Declaración y ámbito de variables”

(Unidad 2, subtema 2.1.1.) se debe saber que 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. Esto se puede ver en el siguiente párrafo:

“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:

• false cuando el tipo de dato es boolean.

• null para un array de objetos de tipo Object.

• el equivalente a 0 (vacio para String) para cualquier otro tipo de dato.

Cuando se hace la declaración de un array en Java se consideran dos posibles opciones:

Declararlo vacío o Declarar colocando valores.



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.

3. Elabora un cuadro sinóptico en el que identifiques los diferentes tipos de arreglos y

sus diferencias.


5. Contribuye con algún comentario a por lo menos dos compañeros(as) sobre su

discernimiento del tema.

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:

Si, por alguna necesidad especial de la situación, se quisiera imprimir a pantalla el

contenido del array nombres indicando la posición de cada nombre, bastaría con hacer lo

siguiente:



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.

Finalmente se le indica al arreglo que se quiere hacer el recorrido de sus elementos de

uno en uno (aunque podría ser diferente, de dos en dos por ejemplo) para poder obtener

el contenido total del array, en el ciclo for se le indica con la instrucción i++. Así, a la hora

de colocar la línea de impresión System.out.println(nombres[i]+” está en la posición ”+i);

hacemos referencia al elemento i-ésimo indicado entre corchetes, pero en lugar de

indicarle un número fijo, se le indica la posición que se desea imprimir con la variable i

que a voluntad del programador iniciará, terminará y se irá incrementando según lo

explicado de las partes que conforman al ciclo for.

4.1.3. Operaciones

Al referirse a “operaciones” con arrays no es en el sentido clásico de operaciones

aritméticas sobre ellos (aunque se pueden hacer y se ejemplificará) sino a cómo se



obtienen sus elementos, haciendo un profundo énfasis en la importancia que tienen los

índices para ello.

Imagina que tenemos 2 arreglos unidimensionales, como sigue:

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.

Actividad 2. Operaciones con arreglos

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.

8. Guarda la actividad con el nombre POO_U4_A2_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.

9. Revisa y comenta los proyectos de al menos dos compañeros(as).

10. Envía el archivo a tu Facilitador(a)para recibir retroalimentación.

4.2 Arreglos multidimensionales

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).

En cambio los multidimensionales se manejan a manera de tabla, donde se tendrán filas y

columnas, por lo que este tipo de arreglos ofrece un mejor manejo de datos cuando éstos

deben manejar dimensiones, como la información mostrada en hojas de cálculo o tablas

de bases de datos.



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.

Cuando se hace la declaración de un array en Java se consideran dos posibles opciones:

Declararlo vacío o Declarar colocando valores.

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:

Declarar colocando valores

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

El recorrido de los elementos de un array multidimensional es de la misma manera que en

un arreglo unidimensional, sólo agregando un corchete por cada dimensión que se añada,

considerando lo siguiente:

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.

Tómese como ejemplo el siguiente código, donde se recorre e imprime el array

bidimensional llamado nombres:

La salida esperada para esta porción de código será:

Observa el aumento de los contadores y la manera en que van incrementándose, ya que

ahí es donde radica la importancia del recorrido de los arreglos, en la posición de sus

contadores.

4.2.3. Operaciones

Como los arrays unidimensionales y multidimensionales son tan parecidos en su método

de acceso (que de hecho es idéntico), se ejemplifica los arrays multidimensionales de la

misma manera que se hizo con los arrays unidimensionales, sólo modificando sus

dimensiones:

Imagina que tenemos 2 arreglos unidimensionales, como sigue:



//recuerda que el número total de elementos de un array multidimensional es la

multiplicación de cada dimensión contra todas las restantes, 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:

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.

Actividad 3. Inversión de arreglos

El propósito de esta actividad es que identifiques la declaración y recorrido de arreglos

multidimensionales en JAVA.


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


primera unidad del curso, es necesario que resuelvas la Autoevaluación de la unidad.




Evidencia de aprendizaje. Menú del curso



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.

6. Consulta la Escala de evaluación.

7. Guarda la evidencia con el nombre POO1_U3_EA_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.


* Recuerda que puedes volver a enviar tu archivo tomando en cuenta las observaciones

de tu Facilitador(a).

Autorreflexiones





Autorreflexiones.

Para saber más

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

• Froufe, A. (2009) Java 2, Manual de usuario y tutorial. México: Alfaomega, Ra-

Ma.

• Hejlsberg, A., Torgersen, M., Wiltamuth, S. & Golde, P. (2011) C# Programming

Language (Covering C# 4.0), The 4th Edition (Microsoft .NET Development

Series). USA: Ed. Addison-Wesley.

04_PD_DS_POO1

Documents

Transcript of 04_PD_DS_POO1