Unidad 1. Introduccion A JAVA1

Análisis y Diseño Orientado a Objetos
U NIVERSIDAD ABIERTA Y A DISTANCIA DE MÉXICO

Unidad 1. Evidencia de Aprendizaje. Mapa mental de los modelos orientados a objetos
Coloca aquí la portada de la actividad con todos los datos que se te solicitan y una ilustración
sobre el tema.
Alumno: Víctor Manuel Salazar García
Docente: Ing. Pedro Blancas Giles
Carrera: Ingeniería en Desarrollo de Software
Asignatura: Programación Orientada a Objetos 1
Grupo: DS-POO1-1402C-001
2014
Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

Ing. Pedro Blancas Giles
Programación Orientada a Objetos 1
Unidad 1. Introducción a Java
1.2 Características del lenguaje JAVA página 10

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 ochenta y 1990 hasta mediados de las décadas 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ónico de consumo, desarrollado por 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 como API’s (interfaz de
programación de interfaz) que dan soporte a acceso a base de daos, 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, 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á 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 considera como un 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.
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 mediantes programas, cualquier
cosa del mundo real puede ser modelado 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.

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 decir la totalidad) en los datos de
aplicación y los métodos que manipulan estos datos, en lugar de pensar estrictamente en términos de los
procedimientos. Si se está acostumbrando 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 experimento 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 y 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 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.
Página 11
Interpretado. Java es un lenguaje interpretado y necesita un intérprete para ejecutar programas. El

compilador de Java genera bytacode 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.
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 un 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 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 son representadas por la palabra reservada class se
puede obtener información en cualquier momento sobre ellas mediante el run-time (en tiempo de
ejecución).
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 los 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 cometen 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.
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 lograra 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 deber 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 describirse 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.
Página 14
Alto Rendimiento. Java es un lenguaje interpretado, por eso no será igual de veloz que en la ejecución como
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- justo a tiempo) 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 componentes.
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 estas características 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 de trabajar con hilos en C o C++ se notará la enorme dificultad que esto representa. La
clase Tharead da 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 código
binario (el ya mencionado bytacode) que se genera a partir del compilador 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

hecha sobre un hardware muy específico, lo que hoy se podría conocer como los modernos Personal Digital
Asisitant (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:
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 Java. Obviamente se deberá tener
configurado en la estación de trabajo la manera 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, procesarlos 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, preocupando por configurar conexiones a base 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.
Página 17 lei

Página 18
Configuración del IDE Enterno Integrado de desarrollo
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 servicio 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 la que proporciona Java) y cómo será la salida de la aplicación
(jar, jar comprimido, entre otros).
1.2.4. Tipos de datos soportados en JAVA
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 como si no se quiere dar un valor inicial, pero si se va a dar un valor colocamos una
asignación con igual y el valor.

Actividad 4 Desarrollada
Página 21 leí
Actividad 5 Desarrollada
Página 21 leí

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:
Página 26 Leí
Página 27
1.3.1. Estructura general
Al hacer la implementación del ejemplo anterior a algo 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.
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 indica 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.
Página 29
Identificadores
Se entenderá al identificador como aquella palabra o nombre que el programador le asigna a sus propias
variables. 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 puede utilizar a continuación números (0 al 9). Pero no dejar espacios en blanco, signo de
interrogación? Ó símbolo de %.
 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.
 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úsculas y la primera letra de las subsecuentes se escribe en mayúsculas.
 Como se mencionó se puede utilizar el símbolo 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úsculas y
dificultan la lectura y separación de la misma, por ejemplo: VALOR_GENERAL_ANUAL_.

Página 30
1.3.2. Convenciones de la programación.

Página 31
1.3.3. Palabras reservadas

Se entiende como palabra reservada a un tipo especial de identificador 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 esta palabras reservadas en
la siguiente tabla:
Aunque la definición del lenguaje Java toma en cuenta todas estas palabras, en su implementación no se
toman en cuenta todas, las que están marcadas con un asterisco aún no tienen utilización
También existen palabras reservadas de empleo específico para nombres de métodos y éstas son:
1.3.4. Estructuras de una clase

Apegándose estrictamente a los lineamientos que genera la documentación de Java, una clase deberá
contener las siguientes partes:
 Packege: 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 necesario (contenidos en otras
packeges) 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.
Página 133
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 el 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 daos, 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.

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).
Página 34

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á formada 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:
Página 51
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 el 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.
Página 52 leí
Página 55
2.1.2. Declaración de constantes

Des de 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 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.

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 “regresa” 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 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:
public static void main(String[] args){
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, doublé, float, entre otros) u objetos.
Cuando 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 como, 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:
Página 58
public int obtener_potencia(int base, int potencia){
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 datos de
los parámetros, aunque las variables que enviemos forzosamente deberán coincidir con el tipo que
pretendemos utilizar. Por ejemplo, se completará el llamado del método presentado en el punto anterior.
public static void main (String[] args){
int b = 3; //representando a la base
int p = 2; //representando a la potencia
obtener_potencia(b,p);
…
}
Como información al lector se debe aclarar que se omiten muchas partes de los métodos, sólo son ejemplos
ilustrativos de cada uno de los puntos.
También como punto importantísimo, recordando los tipos de variables, se dirá que en Java los parámetros de
tipo primitivo (int, long, doublé,…) 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 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);
Página 60
Actividad 3. Sobre parámetros

Página 61
Parámetros de entrada: 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.
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 primitivo (int, doublé,
float, entre otros) u objetos.
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.
Paso de parámetros: Cuando se invoque (llame) el parámetro que se quiere utilizar, deberemos pasarle los
parámetros indicados (necesarios) en su declaración.
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.
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, se 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 apropiada o
no y esto lo indica en un mensaje.
Página 63
Package ejemplos;
/**
* @author ESAD
*/
public class estructuraIF {

int calificación=80;
if(calificación> 70){
System.out.print(“Aprobado”);

}
else {
System.out.print(“Reprobado”);
}
System.out.print(“esto se imprimirá se
Cumpla o no la condición”);
}
}

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 calificación=90;
if(calificación> 90 && calificación <=100){

System.out.print(“Excelente”);
}
else if (calificación >80 && calificación <=90)}
System.out.print(“Muy bien”);
}
else if (calificación>70 && calificación <=80)}
System.out.print(“Bien”);
}
else if (calificación<70)}
System.out.print(“Muy Mal”);
}
}
}
En este ejemplo evaluamos que si su calificación está entre 90 y 100 se mostrará un mensaje diciendo “muy
bien”, sino tienes una calificación entre 90 y 100, pero si estás 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 cómo 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 que
se vieron en la unidad anterior.
2.4.3.
La estructura selectiva swicth – case también es conocida como estructura de decisión múltiple, en esta
estructura se pueden 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 específico, se muestra la
estructura a continuación:
//Instrucciones previas a la condición
switch (expresión){
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 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:
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 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 ejemplos Switch{
int mes= Integer.parseInt(JOptionPane.showInputDialog(“Cúal es en 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 mese que existen, al encontrar el valor correspondiente mostrará el nombre del mes, y en caso de
que el usuario ingrese un número no válido como 20, el programa mostrará un mensaje diciendo “Mes no
válido”.
Entonces si quieres usar un programa donde las comparaciones sean muy específicas puedes usar un
switch, y el caso de evaluar rangos, utiliza un if.

Actividad 4. Programa Horóscopos

Página 66
package ejemplos:
/**
*@author ESAD
*/
public class ejemplos Switch{
int dia= Integer.parseInt(JOptionPane.showInputDialog(“Cúal es dia de nacimiento”));
int mes= Integer.parseInt(JOptionPane.showInputDialog(“Cúal es en 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”);
}
}
}
Versión final de actividad 4

package actividades;
import java.util.Scanner;
/**
*

* @author VICTOR
*/
public class unidad2_A4_2 {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
int dia = Integer.parseInt(JOptionPane.showInputDialog("Cúal es en número del dia"));
int mes = Integer.parseInt(JOptionPane.showInputDialog("Cúal es en número del mes"));
switch(mes) {
case 1:
// Enero
if (dia>=21)
System.out.println("Acuario");
else
System.out.println("Capricornio");
break;
case 2:
// Febrero
if (dia>=19)
System.out.println("Piscis");
else
System.out.println("Acuario");
break;
case 3:
// Marzo
if (dia>=21)
System.out.println("Aries");
else
System.out.println("Piscis");
break;
case 4:
// Abril
if (dia>=21)
System.out.println("Tauro");
else
System.out.println("Aries");
break;
case 5:
// Mayo
if (dia>=21)
System.out.println("Geminis");
else
System.out.println("Tauro");
break;
case 6:
// Junio
if (dia>=21)
System.out.println("Cancer");
else
System.out.println("Geminis");
break;
case 7:
// Julio
if (dia>=21)
System.out.println("Leo");
else
System.out.println("Cancer");
break;
case 8:

// Agosto
if (dia>=22)
System.out.println("Virgo");
else
System.out.println("Leo");
break;
case 9:
// Septiembre
if (dia>=23)
System.out.println("Libra");
else
System.out.println("Virgo");
break;
case 10:
// Octubre
if (dia>=23)
System.out.println("Escorpio");
else
System.out.println("Libra");
break;
case 11:
// Noviembre
if (dia>=23)
System.out.println("Sagitario");
else
System.out.println("Escorpio");
break;
case 12:
// Noviembre
if (dia>=21)
System.out.println("Capricornio");
else
System.out.println("Sagitario");
break;
default:System.out.print("mes no válido");
}
}
}
2.5. Estructuras de control cíclicas

Página 67
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 la condición.
Como regla general puede decirse que se utilizará:
 Ciclo for (para--veces exactas) cuando se conozca de antemano el número exacto de veces que ha
de repetirse un determinado bloque de instrucciones.
 Ciclo do-while (hacer mientras- al menos una repetición) cuando no se conoce exactamente el
número de veces que se ejecutará el ciclo pero se sabe por lo menos que se ha de ejecutar una.
 Ciclo while-do (mientras que hacer--posiblemente no se ejecute ninguna) cuando es posible que
no deba ejecutarse ninguna vez.
Página 67

Estas reglas son generales y algunos programadores se sienten más cómodos utilizando principalmente una
de ellas. Con mayor o menor esfuerzo, pueden utilizarse cualquiera de ellas indistintamente.
2.5.1. While (mientras)

El ciclo while tiene como características que primero evalúa la condición y solo si se cumple realiza las
instrucciones, así es que la condición no es cumplida desde un inicio el control del programa entrará en el
bloque de instrucciones que se encuentran dentro del ciclo. Su declaración es como se muestra a
continuación:
while (condición){
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:

packege ejemplos;
/**
*@author
*/
public class ejemploWhile {
int n=Integer.parseInt(JOptionPane.showInputDialog(“Ingresa el 9”));
while(n !=9){
n=Interger.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 al 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.
Página 68
2.5.2. Do-While (hacer mientras)

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(condición);
Veamos el siguiente ejemplo:

package ejemplos;

/**
@author
*/
public class ejemploDoWhile{
public static void main (String [] args){
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 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 (para)

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; incremente){
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
*/
public class ejemploFor {

int n= Integer.parseInt(JOptionPane.showInputDialog(“Cúantos 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 incremento será de uno en uno.
Otro punto importante respecto al ciclo for es que se pueda 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:
packege ejemplos;
@author
public clas forAnidado{

int n= Integer.parseInt(JOptionPane.showInputDialog(“Cuántos temas son”));
int m= Integer.parseInt(JOptionPane.showInputDialog(“Cuántos 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 hasta que el segundo termine sus repeticiones, el primero volverá a incrementar su valor y volverá
a entrar al segundo tomando sus valores iníciales.
Nota: Si se quisiera anidar más de 2 ciclos for es posible realizarlo, tomando en cuenta que siempre el ciclo
que se encuentre más dentro 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 en un recorrido
inverso.

package ejemplos;
/**
@author
*/
public class ejemploFor2 {

int n= Integer.parseInt(JOptionPane.showInputDialog(“Cúantos 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 números descendentes.

Actividad 5
Página 72
/**
*
* @author VICTOR
*/
public class unidad2_A5 {
int numero1 = 0;
int numero2 = 0;
System.out.println("Unidad 2. Actividad 5. Programa retorno de parámetros");
numero1= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el primer número"));
numero2= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el segundo número"));
int varSuma= suma(numero1, numero2);
int varResta = resta(numero1, numero2);
int varMultiplicacion = multiplica(numero1, numero2);
System.out.println("La suma de 1=" + numero1 + " mas 2=" + numero2 + " es: " + varSuma );
System.out.println("La resta de 1=" + numero1 + " menos 2=" + numero2 + " es: " + varResta );
System.out.println("La multiplicacion de 1=" + numero1 + " y 2=" + numero2 + " es: " + varMultiplicacion );
areaCuarado(numero1);
areaTriangulo(numero1, numero2);
areaCirculo(numero1);
}
static int suma(int a, int b){
int c = a+b;
return c;
}
static int resta(int a, int b){
int c = a-b;
return c;
}
static int multiplica(int a, int b){
int c = a*b;
return c;
}
static void areaCuarado(int a){
int c=a*a;
System.out.println("El area de un cuadrado con lado 1=" + a + " es: " + c );
}
static void areaTriangulo(float a, float b){
float c=(a*b)/2;
System.out.println("El area de un triangulos con altura " + a + " y base " + b + " es: " + c );
}
static void areaCirculo(double a){
double pi = 3.14;
double b = pi * (a*a);
System.out.println("El area de un circulo con radio " + a + " es: " + b );
}
}

Evidencia de Aprendizaje
Página 73
/**
*
* @author VICTOR
*/
public class unidad2_EvidenciadeAprendizaje {
int numeroUno =0;
int numPar = 0;
System.out.println("Unidad2. Evidencia de aprendizaje. Programa de series numéricas");
numeroUno= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el número a evaluar"));
if(numeroUno > 0)
{
numPar = numeroUno % 2;
if(numPar == 0)
{
System.out.println("El Factorial del número " + numeroUno);
long resultado = Factorial(numeroUno);
System.out.println(resultado);
}
else
{
System.out.println("Serie fibonaci para ");
Fibonaci(numeroUno);
}
}
else
{
System.out.println("Número Invalido");
}
}
static void Fibonaci(int numero)
{
int fibo1=1;
int fibo2=1;
System.out.print(fibo1 + " ");
for(int i=2;i<=numero;i++){
System.out.print(fibo2 + " ");
fibo2 = fibo1 + fibo2;
fibo1 = fibo2 - fibo1;
}
System.out.println();
}
static long Factorial(int numero)
{
int i;
long r = 1;
for(i = 1; i <= numero; i++)
{
r = r * i;
}
return r;
}
}

Unidad 3. Características de POO y Excepciones

Página 75
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 (extenderlo). 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 la 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.
En un ejemplo más sobre la herencia de la superclase hacia la subclase debe imaginarse que se cuanta 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:

public class Dibujacirculo {
//esta es la abstracción del círculo.
public Circle c;
//Métodos anteriores.
public double area() {return c.area();}
public doublé circunference() {return c.circunference();}
//Las nuevas variables y métodos irán aquí.
public Color outline, fill;
public void imprimeCirculo(DrawWindow dw) {/* código obviado */}
}
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 de 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
Dibujandocirculo, como ya se había explicado. Se presenta a continuación:
public class Dibujando circulo extends circulo {
//Se heredan automáticamente los métodos y atributos de
// circulo, por lo que no es necesario volver a reescribirlos aquí.
Color outline, fill;
public void imprimeCirculo(DrawWindow dw) {
dw.drawCircle(x, y, r, outline, fill);
}
}
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 superclase
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 la 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.

Página 78
3.1.3. Clases y métodos abstractos

Con la salida a la luz del paradigma de programación orientado a objetos, de igual manea surgieron muchos
problemas inherentes a la comprensión sobre la forma de representar cosas y más aún conceptos en forma
de 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 (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 utilizad 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.
Una clase abstracta es una clase que contiene los nombres de los comportamientos sin las implementaciones
que ejecutan esos comportamientos.
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.
32.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 interfaces lucen un tanto parecidas a una clase abstracta, sólo
las diferencian el método de declaración:
1. 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 interface se puede considerar una clase abstracta de hecho, y en ella se toma en cuenta lo siguiente:
1. Todos los miembros son públicos.

2. Todos los métodos son abstractos
3. Todos los campos son static y final.
Una interface 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 interface, y
2. El cuerpo que contiene la declaración de los métodos y las constantes que conforman la propia
interface.
Página 81
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 clases.
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 de 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 un dato de tipo string (cadena).
El compilador decide qué uso se le dará en base a los operando de los cuales esté acompañado.
Actividad 1. Herencia y polimorfismo

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
que hereda sus métodos y atributos se llaman superclase.
Polimorfismo: Es la capacidad que permite hacer diferentes implementaciones de los mismos métodos
abstractos; se pueden realizar diferentes implementaciones de un mismo método, para poder adaptarlo a las
necesidades propias de cada clase. Todo esto se refiere a la propiedad por la que es posible enviar mensajes
sintácticamente iguales a objetos de tipos distintos. El único requisito que deben cumplir los objetos que se
utilizan de manera polimórfica es saber responder al mensaje que se les envía.
3.2. Excepciones
Cuando un programa en 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.
La manera de controlar las excepciones es mediante una sentencia llamada try-catch, que si lo traducimos al
español sería algo como intenta-atrapa, y realmente esto es lo que hace la sentencia, pues dentro de 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:

class EjemploExcepcion {
public static void main(String argumentos[]) {
try{
int i=5, j=0;
int k=i/j; //División por cero
}
catch(java.lang.ArithmeticException e){
System.out.print(“Se produjo el error”+e);
}
}
}
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. Tipo 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 produjo 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 pila sea capaz de tratar la
excepción, la máquina virtual Java muestra un mensaje de error y el programa termina.
Página 85
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 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 busca del manejo
de la excepción, por último si tampoco en el método 3 se hizo nada, se va al método4 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

EVIDENCIA DE APRENDIZAJE
package poo1_u3_ea;
public class POO1_U3_EA {

// TODO code application logic here
int numeroUno = 0;
int numeroDos = 0;
System.out.println("Evidencia de aprendizaje. Implementación de clases abstractas");
try
{
numeroUno= Integer.parseInt(JOptionPane.showInputDialog("Ingresa un número"));
numeroDos= Integer.parseInt(JOptionPane.showInputDialog("Ingresa otro número"));
AreaFiguras obj = new AreaFiguras();
obj.areaCuadrado(numeroUno);
obj.areaTriangulo(numeroUno, numeroDos);
obj.areaClrculo(numeroUno);
obj = null;
PerimetroFiguras obj2 = new PerimetroFiguras();
float pCuadrado= obj2.perimetroCuadrado(numeroUno);
float pTriangulo = obj2.perimetroTrlangulo(numeroDos,numeroUno);
float pCirculo = obj2.perimetroClrculo(numeroUno);
System.out.println("El perimetro de un cuadrado con lado " + numeroUno + " es: " + pCuadrado );
System.out.println("El perimetro de un triangulos con altura " + numeroUno + " y base " + numeroDos + " es: " +
pTriangulo );
System.out.println("El perimetro de un circulo con radio " + numeroUno + " es: " + pCirculo );
obj2 = null;
Calculos obj3 = new Calculos();
obj3.calcularVelocidad(numeroUno, numeroDos);
obj3.calcularSegundos(numeroUno, numeroDos);
obj3 = null;
nombreMesDia obj4 = new nombreMesDia();
String mes = obj4.nombreMes(numeroUno);
String dia = obj4.nombreDla(numeroUno);
System.out.println("El nombre del mes es " + mes);
System.out.println("El nombre del día es " + dia);
obj4 = null;
}
catch(java.lang.ArithmeticException e)
{
System.out.println("Error: " + e);
}
}
}
package poo1_u3_ea;
public class PerimetroFiguras extends ClaseAbstracta2 {

public float perimetroCuadrado(float lado){
return (lado + lado + lado + lado);
}
public float perimetroTrlangulo(float base, float altura){
return ((altura * 2) + base);
}
public float perimetroClrculo(float radio){
return (2 * 3.1416F * radio);
}

package poo1_u3_ea;
public class nombreMesDia implements Interface2 {

public String nombreMes(int mes){
switch(mes)
{
case 1:
return "Enero";
case 2:
return "Febrero";
case 3:
return "Marzo";
case 4:
return "Abril";
case 5:
return "Mayo";
case 6:
return "Junio";
case 7:
return "Julio";
case 8:
return "Agosto";
case 9:
return "Septiembre";
case 10:
return "Octubre";
case 11:
return "Noviembre";
case 12:
return "Diciembre";
default:
return "Número incorrecto para calcular el mes";
}
}
public String nombreDla(int dia){
switch(dia)
{
case 1:
return "Lunes";
case 2:
return "Martes";
case 3:
return "Miercoles";
case 4:
return "Jueves";
case 5:
return "Viernes";
case 6:
return "Sabado";
case 7:
return "Domingo";
default:
return "Número incorrecto para calcular el día";
}
}
}
package poo1_u3_ea;

public class AreaFiguras extends ClaseAbstracta1 {

public void areaCuadrado(int lado){
System.out.println("El area de un cuadrado con lado " + lado + " es: " + (lado * lado) );
}
public void areaTriangulo(float base, float altura){
float c=(altura*base)/2;
System.out.println("El area de un triangulos con altura " + altura + " y base " + base + " es: " + c );
}
public void areaClrculo(float radio){
float pi = 3.1416F;
float b = pi * (radio*radio);
System.out.println("El area de un circulo con radio " + radio + " es: " + b );
}
}
package poo1_u3_ea;
public class Calculos implements Interface1 {

public void calcularVelocidad(float desplazamiento, int tiempo){
System.out.println("La velocidad con desplazamiento " + desplazamiento + " y tiempo " + tiempo + " es: " +
(desplazamiento/tiempo) );
}
public void calcularSegundos(int horas, int minutos){
int minutosVar = horas * 60;
int segundos = (minutos + minutosVar) * 60;
System.out.println("Los segundos que tiene " + horas + " horas y " + minutos + " minutos son: " + segundos );
}
}
package poo1_u3_ea;
public abstract class ClaseAbstracta1{

public abstract void areaCuadrado(int lado);
public abstract void areaTriangulo(float base, float altura);
public abstract void areaClrculo(float radio);
}
package poo1_u3_ea;
public abstract class ClaseAbstracta2{

public abstract float perimetroCuadrado(float lado);
public abstract float perimetroTrlangulo(float base, float altura);
public abstract float perimetroClrculo(float radio);
}
package poo1_u3_ea;
public interface Interface1{

public void calcularVelocidad(float desplazamiento, int tiempo);
public void calcularSegundos(int horas, int minutos);
}
package poo1_u3_ea;
public interface Interface2{

public String nombreMes(int mes);
public String nombreDla(int dia);
}

UNIDAD 4. ARREGLOS
4.1Arreglos 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 de 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 de datos que se van a almacenar en él.
La sintaxis genera para declarar e instanciar un array es:

tipo DeDato[] identificadorDelArray = new tipoDeDato[tamañoDelArray]
Además, como ya se mencionó, se pueden usar en Java arrays de cualquier tipo de dato soportado, incluso
los definidos por el usuario:
char x[];
int y[];
clsAlumnos objAlumnos[];
Haciendo referencia al tema presentado antes “Declaración ámbito de variables” (unidad2, subtema 2.1.1.) se
debe saber que la declaración de los arrays en Java se hace mediante una variable referencia, 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”.
Igual que con cualquier variable utilizada, 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 cuando 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.

int números[] = new int[50];
Declararlo con valores iníciales
String nombre[] = {“Juan”, “Pedro”, “Luis”, “Hugo”};
Sería lo mismo escribirlo así:
String nombres[] = new String[4];
nombres[0] = new String(“Juan”);
nombres[1] = new String(“Pedro”);
nombre [2] = new String(“Luis”);
nombres[3] = new String(“Hugo”);
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).
Actividad 1. Arreglos
Arreglos: Es una estructura de datos que contiene una serie de variables a las que se accede a través de los
índices calculados.
Elementos de un arreglo: Son las variables contenidas en un arreglo.
Dimensiones de un arreglo: Es el rango del arreglo que determina el número de índices asociados a cada
elemento del arreglo.
Arreglo unidimensional: Es un arreglo con un rango de 1.
Arreglo multidimensional: Es un arreglo con un rango mayor a 1.
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 decalración de un array de tipo String que contendría 4 elementos,
refiriéndose a los nombres propios de 4 personas:
String nombre[] = {“Juan”, “Pedro”, “Luis”, “Hugo”};
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 hace lo siguiente:
System.out.printl(nombres[0]+” está en la posición 0”);
Donde se indica al arreglo que se quiere imprimir el valor que está en la posición i-énesima, esta instrucción
se le indica al lenguaje Java cuando se pone el nombre del arreglo con el cual se quiere trabajar, siguiendo 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 clase por cuestiones didácticas) sería la siguiente:
Juan está en la posición 0
Pedro está en la posición 1
Luis está en la posición 2
Hugo está en la posición 3
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,00 líneas como las anteriores.
Para solucionar la cuestión anterior de forma un tanto más sencilla se utiliza 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 presente la misma
impresión del contenido del array, pero utilizando un ciclo for.
for (int i=0; i<4; i++){
System.out.println(nombres[i]+” está es la posición “+i);
}
Y la salida será:
Juan está en la posición 0
Pedro está en la posición 1
Luis está en la posición 2
Hugo está en la posición 3
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 inexistentes). 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 le 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.printl(nombres[i]+”está en la posición” +i); hacemos referencia al elemento iénesimo 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.
Página 94
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:

Int[] a= new int[10];
int[] b = new int [10];
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:
int c[] = new int[10]; // array que contendrá los resultados de la suma
int d[] = new int[10]; // arran que contendrá los resultados de la multiplicación
int acumulacionSuma = 0;
in acumulacionMultiplicación = 0;
for(int i=0; i<10; i++){
c[i]= a[i]+b[i];
d[i]=a[i]*b[i];
acumulacionSuma += c[i];
acumulacionMultiplicación *= d[i];
}
//imprimimos el resultado de sumar los arrays
for(int i=0; i<10; i++){
System.out.println(c[i]+”,”);
}
//imprimimos el resultado de multiplicar los arrays
for(int i=0; i<10; i++){
System.out.println(d[i]+”,”);
}
//imprimimos las acumulaciones
System.out.prinln(“Acumulación de la suma es “+acumulacionSuma);
System.out.prinln(“Acumulación de la multiplicación es “+acumulacionMultiplicación);
//termina la ejecución
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 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 quiere mostrar.

Actividad 2. Operaciones con arreglos Página 96

package poo_u4_a2;
public class POO_U4_A2{

System.out.println("Actividad 2. Operaciones con arreglos");
ActividadDos();
}
static void ActividadDos()

{
int tamanioArray = 0;
int numero = 0;
int numeroCubo = 0;
tamanioArray= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el número de elementos"));
int arrayInt[] = new int[tamanioArray];
for(int c=0; c<tamanioArray;c++){
numero= Integer.parseInt(JOptionPane.showInputDialog("Ingresa un número"));
arrayInt[c] = numero;
}
for(int c1=0;c1<tamanioArray;c1++)
{
numeroCubo = arrayInt[c1] * arrayInt[c1] * arrayInt[c1];
System.out.println("El número " + arrayInt[c1] + " elevado al cubo es: " + numeroCubo);
}
}
}

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 de datos cuando éstos deben manejar dimensiones, como la
información mostrada en hojas de cálculo o tablas de base 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:
tipoDeDato[][]… identificadorDelArray =
new tipoDedato[tamañoDimensión][tamañoDimensión][tamañoDimensión]…
Además, como ya se mencionó, se pueden usar en Java arrays de cualquier tipo de dato soportado, incluso
los definidos por el usuario:
char x[][];
int y[][];
clsAlumnos objAlumnos[][];
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 alojadas 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.
int números [][]= new int [3][3];
La estructura general, si pudiera observarse la reserva de memoria que hace Java sobre la memoria principal
de la computadora, sería como sigue:
000
000
000
Declarar colocando valores
int numeros2[][]= {{1,2,3},
{4,5,6},
{7,8,9}}
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:

int números[ ] [ ]=new int [5][3];

quedaría así
000
000
000
000
000
Declararlo con valores iníciales 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.
String nombres[] = {{“Juan”, “Pedro”, “Luis”, “Hugo”},
{“Ana”, “Paulina”, “Alan”, “Blanca”}};
Sería lo mismo escribirlo así:
String nombres [ ][ ]= new String[2][4];
nombres[0][0] = new String(“Juan”);
nombres[0][1] = new String(“Pedro”);
nombres[0][2] = new String(“Luis”);
nombres[0][3] = new String(“Hugo”);
nombres[1][0] = new String(“Ana”);
nombres[1][1] = new String(“Paulina”);
nombres[1][2] = new String(“Alan”);
nombres[1][3] = new String(“Blanca”);
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.
Página 100
Tómese como ejemplo el siguiente código, donde se recorre e imprime el array bidimensional llamado
nombres:
for (int i=0; i<2; i++){//contador encargado de recorrer las filas
for(int j=0; j<4; j++){//contador encargado de recorrer las columnas
System.out.printl(nombres[i][j]+” está en la posición “+i+”-“+j+” del array”);
}
}
La salida esperada para esta porción de código será:
Juan está en la posición 0-0 del array

Pedro está en la posición 0-1 del array
Luis está en la posición 0-2 del array
Hugo está en la posición 0-3 del array
Ana está en la posición 1-0 del array
Paulina está en la posición 1-1 del array
Alan está en la posición 1-2 del array
Blanca está en la posición 1-3 del array

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:

int[ ][ ] a = new int[10][10];// en lugar de ser 10 números ahora serán 100
int[ ][ ] b = new int[10][10];// en lugar de ser 10 números ahora serán 100
//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 el 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:
int c[ ] = new int[10][10]; //array que contendrá los resultados de la suma
int d[ ] = new int[10][10]; //array que contendrá los resultados de la multiplicación
int acumulacionSuma = 0;
int acumulacionMultiplicación = 0;
for(int i=0; i<10; i++){//acceso a las filas
for(int j=; j<10; j++){//acceso a las columnas
c[i][j]=a[i][j]+b[i][j];
d[i][j]=a[i][j]*b[i][j];
acumulacionSuma +=c[i][j];
acumulacionMultiplicacion *=d[i][j]
}
}
for(int j=0; j<10; j++){//acceso a las columnas
System.out.println(c[i][j]+”,”);
}
System.out.printl();//retorno de carro para darle forma de matriz
}
for(int j=0; j<10; j++){//acceso a las columnas
System.out.println(d[i][j]+”,”);
}
System.out.printl();//retorno de carro para darle forma de matriz
}
//imprimimos las acumulaciones
System.out.printl(“Acumulación de la suma es “+acumulacionSuma);
System.out.printl(“Acumulación de la multiplicación es “+acumulacionMultiplicacion);
//Termina la ejecución
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 quisiera mostrar.
Página 102
Actividad 3 Inversión de arreglos

package poo_u4_a3;
public class POO_U4_A3 {

System.out.println("Actividad 3. Inversión de arreglos");
System.out.println("Mi name");
System.out.println("Matricula");
ActividadTres();
}
static void ActividadTres()

{
int tamanioArray1 = 0;
int tamanioArray2 = 0;
int numero = 0;
tamanioArray1= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el número de elementos para las filas"));
tamanioArray2= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el número de elementos para las
columnas"));
int arrayInt[][] = new int[tamanioArray1][tamanioArray2];
for(int c=0; c<tamanioArray1;c++){
for(int c1=0; c1<tamanioArray2;c1++){
numero= Integer.parseInt(JOptionPane.showInputDialog("Ingresa un número"));
arrayInt[c][c1] = numero;
}
}
System.out.println("Array Inverso:");
for(int c2=(tamanioArray1-1);c2>=0;c2--)
{
for(int c3=(tamanioArray2-1);c3>=0;c3--)
{
System.out.print(arrayInt[c2][c3] + " ");
}
System.out.println("");
}
}


Unidad 1. Introduccion A JAVA1

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Unidad 1. Introduccion A JAVA1

Cargado por

Copyright:

Formatos disponibles

Análisis y Diseño Orientado a Objetos

U NIVERSIDAD ABIERTA Y A DISTANCIA DE MÉXICO

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

Unidad 1. Introducción a Java

1.2 Características del lenguaje JAVA página 10

1.2.1. Generalidades de JAVA

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

Unidad 1. Introducción a Java

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

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

Unidad 1. Introducción a Java

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

Unidad 1. Introducción a Java

1.2.2. Máquina virtual de Java

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

Unidad 1. Introducción a Java

¿Cómo funciona la JVM?

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

1.2.3. Entorno de desarrollo y configuración

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

Unidad 1. Introducción a Java

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

Unidad 1. Introducción a Java

Configuración del IDE Enterno Integrado de desarrollo

1.2.4. Tipos de datos soportados en JAVA

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

Unidad 1. Introducción a Java

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

Unidad 1. Introducción a Java

1.2.6. Conversión de tipos de datos

1.3.1. Estructura general

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

Unidad 1. Introducción a Java

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

Unidad 1. Introducción a Java

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

Unidad 1. Introducción a Java

1.3.3. Palabras reservadas

1.3.4. Estructuras de una clase

 Packege: Es el apartado que contendrá la definición de directorios o jerarquía de acceso a donde

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

Unidad 1. Introducción a Java

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

1.3.5. Declaración de objetos y constructores

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

Unidad 1. Introducción a Java

Quedando la instrucción como sigue:

empleado objetoE=new empleado();

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

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

Unidad 1. Introducción a Java

2.1 Generalidades de los métodos

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

 Un bloque de código que tiene un nombre,

2.1.1. Declaración y ámbito de variables

2.1.2. Declaración de constantes

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

Unidad 1. Introducción a Java

2.2 Métodos que no devuelven valores