Curso PDF

CURSO DE FUNDAMENTOS DE JAVA
Hola, te saluda Ubaldo Acosta. Bienvenida y bienvenido. Espero que estés listo para empezar esta
aventura con nosotros. Si ha sido tu sueño convertirte en un experto Java, te felicito por que estás en
el lugar correcto. A lo largo de este curso comenzarás tu camino para convertirte en un especialista
Java como siempre lo has deseado. No necesitas conocimientos previos ya que comenzaremos desde
cero. Este curso es ideal si estás comenzando con el lenguaje Java.
Vamos a comenzar.
© Todos los Derechos Reservados Global Mentoring Experiencia y Conocimiento para tu Vida 2
Sabemos lo difícil que es comenzar con el estudio de la tecnología Java, desde problemas de precios,
contenido, aprendizaje del mundo real, etc. Cualquiera que haya sido tu necesidad de aprender la tecnología
Java, estás en el lugar correcto.
Mi nombre es Ubaldo Acosta, fundador de GlobalMentoring.com.mx y en los últimos 6 años nos hemos
dedicamos en crear cursos Online con especialización en la tecnología Java; por ello en Global Mentoring
hemos creado la Universidad Java, con la cual te garantizamos que en tiempo record podrás incorporarte en el
mercado laboral Java o crear la aplicación que siempre has deseado.
En este curso, Fundamentos de Java, nos esforzaremos para que sientes las bases de la programación en
Java, pero no desde un punto de vista académico, sino las bases que te permitirán ir creciendo siempre
pensando en proyectos del mundo real, así que te enseñaremos no solo lo que es básico e importante
aprender, sino también cuestiones del mundo real, con ejercicios que iremos aplicando para así dejar muy
claro y de una vez por todas las bases de la buena programación en Java.
En Global Mentoring estamos conscientes de que la mejor manera de transmitir el conocimiento que
necesitas para tus proyectos Java es a través de cursos eLearning con Videos paso a paso y a tu
propio ritmo.
Esto permite que nuestros estudiantes incrementen sus habilidades técnicas, con el objetivo de
obtener mejores oportunidades en el mercado laboral Java, el cual está en constante crecimiento y
con excelentes remuneración económica.
Nuestra metodólogía consiste en Cursos en Video paso a paso, también incluimos eBooks que son
PDF en español. Así mismo tienes acceso todos los días de la semana, durante las 24 horas del día
durante tu acceso a tus cursos para que puedas estudiar y aprovechar al máximo tu acceso a la
plataforma eLearning.
Además cuentas con soporte online de cualquier duda de tu material didáctico, apoyado por un
instructor Java Certificado y con amplia experiencia en el mercado laboral Java.
Al finalizar cada nivel se te entregará un reconocimiento en PDF con el cual puedes demostrar tus
conocimientos en el mercado laboral.
Así que con nuestra metodología tienes garantizado tu aprendizaje en la tecnología Java.
En Global Mentoring promovemos la Pasión por la Tecnología Java. Te invitamos a visitar nuestro
sitio Web donde encontrarás cursos Java Online desde Niveles Básicos, Intermedios y Avanzados, y
así te conviertas en un experto programador Java.
A continuación te presentamos nuestro listado de cursos:
Lógica de Programación Hibernate Framework

Fundamentos de Java Spring Framework
Programación con Java JavaServer Faces
Java con JDBC Java EE (EJB, JPA y Web Services)
HTML, CSS y JavaScript JBoss Administration
Servlets y JSP’s Android con Java
Struts Framework HTML5 y CSS3
Datos de Contacto:
Sitio Web: www.globalmentoring.com.mx

Email: informes@globalmentoring.com.mx
Hola, te saluda nuevamente Ubaldo Acosta. Espero que estés listo para comenzar.
Vamos a revisar el temario general del curso de Fundamentos de Java.
¿Estás listo? ¡Vamos!
Vamos a revisar el contenido general del curso de Fundamentos de Java:
Comenzando.- La tecnología Java: En esta sección estudiaremos las características principales del lenguaje Java, el origen y la
evolución hasta el día de hoy. También revisaremos los distintos productos y versiones que nos ofrece la tecnología Java, y daremos
un vistazo a la máquina virtual de Java para entender cómo funciona la ejecución de programas Java. Además realizaremos la
instalación de las herramientas que vamos a utilizar a lo largo del curso y crearemos un primer proyecto HolaMundo con Java.
Componentes Básicos.- Variables y Operadores: En esta sección revisaremos el concepto y variables en Java, así como los tipos
de datos que nos ofrece este lenguaje de programación. Daremos un vistazo rápido al manejo del tipo String y crearemos algunos
ejercicios para poner en práctica estos conceptos. También, examinaremos los tipos de operadores que nos ofrece Java, así como
las palabras reservadas del lenguaje. Crearemos algunos ejercicios para poner en práctica el uso de operadores, así como la
precedencia de operadores en Java.
Estructuras Básicas.- Sentencias de Control: Revisaremos las sentencias de control if/else y switch. La sintaxis de cada uno, así
como creamos algunos ejercicios para poner en práctica estos conceptos. También revisaremos más operadores Java, los cuales se
utilizarán constantemente al utilizar las sentencias de control if o switch.
Estructuras Básicas.- Ciclos en Java: En esta sección analizaremos los ciclos while, do-while y for en Java. Estudiaremos la
sintaxis de cada uno y creamos varios ejercicios para aprender cada uno de estos conceptos.
Programación Orientada a Objetos.- Clases y Objetos en Java: En esta sección definiremos los conceptos de Clases y Objetos
en Java. Veremos la estructura general para construir una clase en Java, y veremos la sintaxis para construir objetos a partir de una
clase. Estos conceptos son pilares en la tecnología Java. Crearemos varios ejercicios para poner en práctica estos conceptos.
Las Funciones.- Métodos en Java: Definiremos qué es un método, así como la sintaxis en Java para crear objetos. Veremos cómo
hacer llamadas de métodos y crearemos un ejercicio para poner en práctica este concepto tan importante en Java.
Diseño de Clases.- Herencia y Encapsulamiento: Aprenderemos el concepto de Herencia en Java y cómo llevarlo a la práctica en
nuestros proyectos. Además revisaremos el concepto de encapsulamiento y cómo aplicarlo a nuestras clases Java.
Manejo de Datos.- Arreglos y Matrices: Estudiaremos el concepto de Arreglos y Matrices en Java. Ambos conceptos son las
estructuras de datos más básicas que utilizaremos, pero muy potentes ya que las encontraremos en la mayoría de los proyectos
Java en los que trabajemos. También crearemos varios ejercicios para dejar claro estos conceptos.
A grandes rasgos este es el temario general del curso de Fundamentos de Java. Estos son tan solo algunos de los muchos más
temas que aprenderemos a lo largo de este curso. Así que si estás listo, comencemos de inmediato.
sitio Web donde encontrarás cursos Java Online desde Niveles Básicos, Intermedios y Avanzados,
y así te conviertas en un experto programador Java.
Lógica de Programación Hibernate Framework & JPA

Datos de Contacto:

Hola, te saluda Ubaldo Acosta. Bienvenidos nuevamente.
En esta primera lección vamos a estudiar una introducción a la tecnología Java, veremos qué es el
lenguaje Java y por qué es importante al día de hoy dominar esta tecnología. Una de las principales
razones por las cuales convertirse en un experto Java es que existe una demanda increíble de
profesionales bien capacitados en la tecnología Java, pero poca gente preparada para afrontar estos
retos, así que es el mejor momento para que tomes ventaja y te conviertas en un especialista de una
vez por todas.
A lo largo de esta lección estudiaremos, entre otros temas, las distintas versiones de Java, y la
evolución de esta tecnología hasta nuestros dias.
También, estudiaremos las características más importantes de Java y las razones de peso por las
cuales Java es considerado el lenguaje número uno a nivel mundial actualmente.
Así, si estás listo, de este lado también ya tenemos todo preparado para comenzar este fabuloso
viaje en el aprendizaje del lenguaje de programación más popular del mundo, Java.
Comencemos de inmediato.
Java es más que un lenguaje de programación, es una tecnología muy completa y considerada como la opción
número uno para muchos de los desarrollos empresariales al día de hoy. Pero vamos a comenzar por los elementos
básicos, por lo que en estas lecciones estudiaremos Java como un lenguaje de programación desarrollado por Sun
Microsystems. Me gustaría comentarles que aunque vamos a tocar algunos puntos históricos, no es nuestra intención
hacer anotaciones de cosas obvias que pueden encontrar en internet, sino únicamente con la intención de ponerlos en
contexto, y tengamos un panorama general de lo que vamos a aprender.
Java nace a principios de los años 90, creado por James Gosling, con el objetivo de crear un lenguaje de
programación que se utilizara en la nueva generación de dispositivos inteligentes. Se intentó utilizar C++ y extenderlo,
sin embargo resultó complicado este lenguaje y James Gosling decidió crear un nuevo lenguaje llamado OAK,
posteriormente se cambió el nombre a Java (cuenta la leyenda que decidieron escoger el nombre de Java debido al
café que acostumbraban beber, Java es un tipo de café proveniente de Asia). Cualquiera que haya sido el origen del
nombre, Java es al día de hoy un nombre que todo aquel que utiliza una computadora tiene presente, ya sea por su
máquina virtual de Java, o algún plug-in de Java, y esto se debe a que muchas aplicaciones instaladas en nuestra
computadora utilizan a Java como lenguaje de programación.
El éxito de Java radicó en la posibilidad de instalar un componente, conocido como Applet, en un navegador Web, y
con el boom de internet fue posible extender este concepto a cualquier página Web y comenzar a ejecutar
aplicaciones Java en cualquier parte del mundo.
Al pasar los años, el éxito de Java, no solamente en internet sino en la creación de sistemas empresariales, hizo que
Oracle pusiera los ojos en esta tecnología, y finalmente en 2009 fuera adquirido por esta mega empresa de software.
Han pasado ya varios años desde la adquisición de Java por parte de Oracle, y afortunadamente tanto la evolución del
lenguaje, las herramientas y el apoyo por parte de las grandes empresas, así como la comunidad de programadores
Java (contada por millones), sigue haciendo de Java el lenguaje número uno a nivel mundial para la creación de
software de propósito general. Tanto así que Google basó el sistema operativo Android en el lenguaje Java, creando
una extensión del lenguaje conocida como Dalvik.
Por todo lo anterior, el apoyo a la tecnología Java no solamente sigue vigente, sino que vuelve a estar de moda
gracias a las grandes empresas y su decisión de seguir creando software basado en este lenguaje de programación,
así como a la increíble comunidad de programadores Java que sigue fiel y agregando nuevos adeptos día a día a nivel
mundial.
Al día de hoy Java no solamente ha cumplido y superado las expectativas originales de

controlar la nueva generación de dispositivos inteligentes, sino que ahora con el
concepto de Internet de las Cosas será posible controlar casi cualquier cosa que tenga
un chip con una máquina virtual de Java, ya que una de las características más
importantes de Java es la independencia de plataforma, por lo tanto existen infinidad
de dispositivos invirtiendo en crear chips para sus dispositivos inteligentes.
Ejemplos de esto son sistemas de seguridad con cámaras de video, módems,

televisores, bluray, entre muchos tipos de dispositivos más, por ejemplo en temas de
seguridad o sistemas de vigilancia, electrodomésticos controlados por internet, y
cualquier tipo de "cosas" o dispositivos que se conectan y controlan por internet. Esto
es una realidad al día de hoy, y por tanto Java sigue floreciendo, evolucionando y
creciendo con la necesidad cada vez más amplia de tener cualquier "cosa" conectada y
controlada a través de internet.
Esta fue la idea original de Java y es parte muy importante de su evolución, así que si
pensabas que el mercado de Java era cosa del pasado, esto es sólo una pequeña
muestra de todo el futuro que está por ser creado, ya sea en la Web o fuera de ella, y
todo gracias a plataformas como Java.
El éxito de Java reside en varias de sus características, por ejemplo, Java es un lenguaje sencillo, ya que simplificó la mayor parte de la
complejidad de C++. El lenguaje C y C++ aportaron las bases para que Java pudiera ser lo que es al día de hoy.
El lenguaje Java tiene las siguientes características generales:
Orientado a Objetos: A diferencia de lenguajes estructurados (como el lenguaje C), Java define clases para ordenar, clasificar y modelar
la información de los sistemas de información, cualquiera que este sea. Los objetos agrupan estructuras encapsuladas y contienen tanto
sus datos como los métodos (o funciones) que manipulan esos datos.
Simple: Por simplicidad nos referimos a que Java utilizó varias de las características de lenguajes como C y C++, eliminando las
cuestiones que consideró más complejas. Algunas características son la herencia simple, manejo de la memoria, entre muchas más, que
iremos viendo a lo largo del curso.
Distribuido: Java proporciona una colección de clases para su uso en aplicaciones de red, que permiten abrir conexiones con servidores
o clientes remotos, de manera que podemos tener aplicaciones instaladas en distintos servidores o equipos, y aún así acceder a esos
componentes Java de manera remota.
Multi-hilos: Java permite ejecutar varias tareas a la vez, en el cual cada subproceso es un proceso más ligero que si se creara un nuevo
proceso desde cero, a este concepto se le conoce como threads y una de las mayores ventajas es que muchas de las tareas de APIs
avanzadas de Java consideran de manera automática el uso de threads para la ejecución de muchos de los procesos que se utilizan en
la vida real. Así que en variados escenarios obtendremos estos beneficios de manera automática :)
Seguro: La Java Virtual Machine (JVM) no permite que nuestra aplicación utilice recursos fuera del espacio y recursos asignados, de
esta manera, muchas de las aplicaciones Java son más seguras que si se ejecutara código fuera de la caja de Java (JVM).
Independiente de Plataforma: Java tiene independencia de plataforma al crear un código intermedio, que conocemos como Bytecode.
Este código puede ser ejecutado en cualquier plataforma o sistema operativo. De esta manera tenemos varias ventajas, tanto al
momento de crear código Java, como al momento de desplegar o distribuir nuestras aplicaciones, ya que podemos elegir crear nuestro
código en un sistema operativo y ejecutarlo en otro. De aquí viene el dicho "write once - run everywhere“ (escribir una vez-ejecutar donde
sea), ya que haremos el esfuerzo de escribir el código en una plataforma, pero una vez creado es posible ejecutar la aplicación en
múltiples plataformas, trayendo muchos beneficios tanto para el programador como para las empresas.
Estas son sólo algunas de las principales características principales de Java. Conforme vayamos avanzando iremos poniendo en práctica
cada una de ellas y así puedas darte cuenta por ti mismo del poder de Java.
Java se divide en distintos grupos, dependiendo del tipo de solución que se requiera . Sin embargo, todos tienen como fundamento el
lenguaje Java y la máquina virtual de Java, por ello una vez que tenemos conocimiento de este increíble lenguaje de programación, es
posible ir profundizando en cada una de estas tecnologías. Cada versión o edición, incluye su propio SDK (Software Development Kit), el
cual permite a los programadores crear, compilar y ejecutar las aplicaciones creadas en cada versión.
La versión estándar de Java (Java Estándar Edition) se utiliza para crear software para aplicaciones de Escritorio (Desktop) o Applets que se
ejecutan en un navegador Web. Por ejemplo, el software de Netbeans que utilizaremos en este curso es un ejemplo de una aplicación de
Escritorio. En este curso nos enfocaremos precisamente en esta versión estándar y así establecer los fundamentos del SDK de esta
versión, ya que estas son las bases de Java que nos permitirán profundizar en otros cursos, tanto en esta misma versión estándar como en
versiones empresariales que platicaremos a continuación.
La versión empresarial conocida como Java EE, se utiliza para crear aplicaciones empresariales de gran escala, de lado del servidor, y este
tipo de aplicaciones pueden ser accedidas desde clientes creados con la versión estándar, o cualquier otro tipo de cliente, como clientes
Web, o Servicios Web, entre otros. La versión empresarial de Java anteriormente se conocía como J2EE, así que si encontramos mención
de esta versión, ya sabemos que hace referencia a la versión empresarial de Java. El estudio de esta versión queda fuera del alcance de
este curso, pero en GlobalMentoring.com.mx contamos con cursos para aprender y profundizar en esta versión de Java Empresarial.
Finalmente, la versión JME es la versión Micro de Java con el objetivo de crear aplicaciones para celulares y dispositivos móviles, así como
microchips para cámaras de seguridad, GPS, routers, o cualquier dispositivo con una capacidad mucho menor tanto de procesamiento
como de almacenamiento. Cabe mencionar que el sistema Android instalado en miles de celulares y dispositivos móviles toma como base
el lenguaje Java y la máquina virtual de Java, y crea una extensión llamada Dalvik para poder ejecutar código Java sobre Android. Esto
hace que Java siga más vigente que nunca no solamente en el tema de aplicaciones de escritorio y en el ambiente empresarial (en el que
es el lenguaje de programación número 1), sino que ahora también con este crecimiento de Android, el lenguaje Java se ha popularizado
en el tema de dispositivos móviles con Android. El tema de Android queda fuera del alcance de este curso, pero en
GlobalMentoring.com.mx contamos con capacitación online para aprender esta tecnología muy de moda entre los programadores.
En conclusión, podemos observar que Java no es sólo un lenguaje de programación, sino que es toda una tecnología que abarca desde
aplicaciones de escritorio, empresariales y aplicaciones móviles, así que Java es ENORME y es por ello que es tan emocionante aprender
esta tecnología, esto sin mencionar los cientos o miles de proyectos, frameworks y tecnologías que extienden, complementan y
enriquecen la tecnología Java.
A continuación veremos las distintas versiones de la versión estándar de Java. En 1996 nace Java,
originalmente llamado OAK. En 1997 surge la versión 1.1 en la que se incluye la primera forma visual de
Java conocida como AWT (Abstract Window Toolkit), entre varias APIs más. Un API (Application
Programming Interface) es un conjunto de clases y librerías para resolver un problema en específico,
por ejemplo surge el API de JDBC que nos permite conectarnos a una base de datos, entre varias APIs
más.
Uno de los cambios más importantes en las versiones de Java, sin duda fueron realizados en la versión
J2SE 5.0 y en la versión Java SE 8.
En la versión J2SE 5.0 se introdujo el concepto de Generics, el cual cambió la forma en que hacíamos
conversión entre objetos Java, asignando un tipo específico a utilizar sobre todo al momento de
trabajar con colecciones. Esto eliminó muchos de los errores de ejecución al manejar tipos objetos y
especificando el tipo de dato que debía contener una colección.
Y el cambio mayor para java, no solamente por los años que han pasado y que ha madurado el
lenguaje, sino por que también implica un cambio de paradigma, es la inclusión de expresiones lambda,
con las cuales podemos combinar el poder de la programación orientada a objetos con la programación
funcional, que si bien no es un nuevo paradigma, si es algo nuevo para los programadores Java.
Se que varios de estos conceptos o temas mencionados son nuevos para muchos de los programadores
que comienzan con Java, sin embargo es precisamente lo que estaremos estudiando en este y en los
siguientes cursos de su especialización en la tecnología Java.
Como podemos observar al día de hoy la tecnología Java sigue dominando el mundo de la
programación, y esta es sólo una de las razones por las cuales estudiar y dominar Java te lleva un
paso delante de cualquier competencia que tengas en el camino.
Sin embargo en muchos casos se nos ha contado que aprender Java es muy difícil, y que nuestras
probabilidades de dominarlo como lo demanda el mercado son pocas, esto es verdad únicamente si
lo crees, por que en realidad con tu empeño y esfuerzo tienes todo a tu favor para poder dominar
este fabuloso lenguaje de programación, y así poder incorporarte en las miles de oportunidades
laborales, tanto nacionales como internacionales que genera el mercado de desarrollo de sistemas
con Java.
Y aunque haya mucha competencia en el mercado de desarrollo de sistemas, al día de hoy sigue
habiendo un déficit de programadores Java, así que siempre habrá muchas oportunidades para gente
bien preparada y que se está especializando como tú 
Además de las características ya descritas de Java, es importante mencionar varias razones más por las cuales ser un
experto en Java.
Afortunadamente existe una comunidad de millones de programadores Java a nivel mundial, esto permite que los
compañeros programadores aporten conocimiento y soluciones a bastantes de los problemas que nos podemos
enfrentar en el día a día, y a diferencia de otros lenguajes y/o plataformas de desarrollo, en las cuales el conocimiento es
muy cerrado, la comunidad de Java aporta abundante contenido gratis a través de internet, así que muchas soluciones
las podremos encontrar a través de estas comunidades y foros de ayuda que a nivel mundial existen.
El soporte a Java que las grandes industrias de software aportan, permite que Java sea la opción número uno al día de
hoy cuando estamos por seleccionar un nuevo proyecto, esto a su vez permite que se generen excelentes oportunidades
laborales a nivel mundial y aunque existen muchos programadores, la demanda de los mismos supera por mucho el
número de programadores que se necesitan para cubrir esta demanda. Esto permite que al estar bien preparados
tengamos una gran cantidad de oportunidades para nuestro crecimiento y desarrollo profesional.
Además, aprender Java facilita aprender otros lenguajes de programación, ya que tanto las buenas prácticas, los
patrones de diseño, frameworks y demás tecnologías que se generan debido al desarrollo con Java suele ser adoptado
por otros lenguajes y tecnologías para facilitar también sus desarrollos de software, así que una vez aprendido Java, será
más simple entender y comunicarnos con otros programadores de otros lenguajes de programación.
Estas son tan sólo algunas de las razones más importantes por las cuales convertirnos en un experto en Java. Con esto ya
tenemos más claro tanto la historia, las características principales y las razones por las cuales dominar Java. A
continuación instalaremos el software de Java y pondremos en práctica los conceptos que estudiaremos y aplicaremos
en este curso.
Empezando con temas un poco más técnicos, podemos ver que para crear programas en Java
necesitamos agregar código a un archivo de texto y con extensión .java.
Este archivo se compila por medio del comando javac, el cual genera el código conocido como
bytecode. Este archivo generado tiene la extensión .class y es el que podemos utilizar para ejecutar
nuestro programa.
Una gran ventaja de contar ya con este archivo es que sin importar dónde escribimos esta clase (por
ejemplo en Windows, Mac o Linux), este archivo se puede ejecutar en cualquier ambiente, sólo
contando con una máquina virtual de Java. De esta manera podemos tener un archivo .class y
ejecutarlo en ambientes Windows, mac o Linux, o cualquier otro sistema operativo o ambiente que
tenga instalada una máquina virtual. A esto se le conoce como write once / run anywhere, ya que a
diferencia de otros lenguajes, en Java escribimos solamente una vez nuestro programa y lo podemos
ejecutar en cualquier plataforma.
Esta es una de las características por las cuales Java es al día de hoy una de las tecnologías más
utilizadas a nivel mundial.
Una de las cuestiones que Java simplificó muchísimo respecta al tema de manejo de memoria, fue la
introducción del concepto de recolector de basura o garbage collector. A diferencia de lenguajes
como C o C++, en los cuales teníamos que manejar el concepto de apuntadores y tener bastante
cuidado respecto a la localidad de memoria en donde hacia referencia los datos de nuestros
programas, en Java la asignación de datos y objetos en la memoria ram se maneja de manera
automática. Esto facilita enormemente el trabajo del programador, ya que se enfoca en tareas más
importantes y productivas que el manejo de memoria.
Como programadores Java, únicamente debemos preocuparnos por crear nuestras variables, sin
importar si son objetos o tipos primitivos (que veremos más adelante) y Java se encargará de
reservar el espacio de memoria necesario para la información del programa. Una vez que nuestro
programa ha dejado de utilizar este espacio de memoria, el recolector de basura o garbage collector,
detecta estos espacios de memoria y los limpia con el objetivo de reutilizarlos para que otro
programa pueda utilizar estos mismos espacios de memoria, haciendo más eficiente el uso de la
misma.
Existen distintas clasificaciones respecto al manejo de memoria en Java, sin embargo esto lo
estaremos estudiando posteriormente a más detalle. De momento solo debemos quedarnos con el
concepto de que es una de las simplificaciones más importantes que aportó Java respecto al manejo
de la memoria de manera dinámica.
Vamos a hablar un poco más del ambiente de ejecución de Java. En Java tenemos dos momentos
importantes al momento de crear y ejecutar nuestro programa. Por un lado tenemos que compilar
nuestro programa, pudiendo encontrar varios errores y debemos corregirlos para que nuestro
programa pueda ser compilado. Durante este proceso se dice que estamos en tiempo de
compilación, y para ello se ejecuta el comando javac (java compiler). Esto en un IDE como Netbeans,
el cual utilizaremos al lo largo del curso, prácticamente con sólo ir escribiendo nuestro código o
guardar nuestro archivo estamos compilando nuestro programa, así que será muy transparente este
proceso de ejecución del comando javac para nosotros. Sin embargo, haremos una práctica para que
puedan visualizar cómo compilar cualquier programa Java desde la línea de comandos.
Por otro lado, una vez que ya se ha compilado nuestro programa y queremos ejecutarlo, se dice que
estamos en tiempo de ejecución, y en este proceso de suceden varias cosas.
Por un lado Java detecta cual es la clase que se desea ejecutar, ya debe existir un archivo con
extensión .class el cual contiene los bytecodes que entiende la máquina virtual de Java. Una vez que
se tiene este archivo .class se carga en memoria, y se revisa que todo esté en orden con el verificador
de bytecode. Posteriormente se ejecuta el interprete de Java el cual hace el proceso transparente
para nosotros de ejecutar nuestro archivo .class en cualquier plataforma, ya sea Windows, Mac,
Linux o cualquier sistema operativo o plataforma que cuente con una máquina virtual. Finalmente la
máquina virtual es la que permite ejecutar nuestro programa sobre el hardware y sistema operativo
seleccionado.
Este es el proceso general cuando creamos, compilamos y ejecutamos nuestros programas en Java.
Esto lo iremos estudiando a detalle en las siguientes lecciones.
A continuación vamos a instalar las herramientas con las cuales vamos a trabajar a lo largo del curso.
Para iniciar vamos a instalar el software de Java para poder crear programas, compilarlos y
ejecutarlos en nuestro equipo. Este es el Java Development Kit, o Kit de Desarrollo de Java.
Dependiendo de la plataforma que utilicemos es el tipo de software que vamos a descargar e
instalar.
Posteriormente y una vez instalado el JDK, vamos a configurarlo para poder utilizar el JDK desde
cualquier parte de nuestro sistema operativo.
También instalaremos el IDE de Netbeans. IDE significa Integrated Development Enviroment o

Ambiente de Desarrollo Integrado. Y nos va a facilitar el desarrollo y creación de software Java e
incluso de otros lenguajes, pero en para cuestiones de este curso será creación de programas en
Java.
Finalmente crearemos nuestro primer programa, tanto ejecutándolo desde la línea de comandos, así
como desde el IDE de Netbeans.
sitio Web donde encontrarás cursos Java Online desde Niveles Básicos, Intermedios y Avanzados, y
así te conviertas en un experto programador Java.

Datos de Contacto:

www.gl obal mentoring.com .mx
Vamos a realizar la instalación del JDK de Java y Netbeans.
Para ello vamos a seguir varias guías en PDF.
Veamos cada una de ellas.

Vamos a instalar el JDK de Java:
Instalación del JDK de Java en Windows:

http://icursos.net/cursos/Instalaciones/CJ-B-Ejercicio-01-Instalacion-jdk-windows.pdf
Instalación del JDK de Java en Mac OS X:

http://icursos.net/cursos/Instalaciones/CJ-B-Ejercicio-02-Instalacion-jdk-mac.pdf

• Con este ejercicio hemos instalado el JDK de Java.
• No basta con tener instalado solo el JRE (Java Runtime

Enviroment), sino debemos instalar un JDK (Java
Development Kit), tal como lo hemos hecho en este
ejercicio.

Por: Ing. Ubaldo Acosta

Vamos a realizar la instalación del IDE de Netbeans.
A pesar de que los cursos utilizan Netbeans, se puede utilizar

cualquier IDE debido a que los ejercicios se crearon para utilizar
sólo puntos más básicos de un IDE, y estas funciones básicas las
tiene cualquier IDE que se desee utilizar. De esta manera nos
enfocaremos en los conceptos y no en las herramientas del IDE.
Seguiremos la siguiente guía en PDF.

Vamos a instalar Netbeans:
Instalación de Netbeans en Windows:
http://icursos.net/cursos/Instalaciones/CJ-B-Ejercicio-04-Instalacion-Netbeans-Windows.pdf
Instalación de Netbeans en Mac OS X:

http://icursos.net/cursos/Instalaciones/CJ-B-Ejercicio-05-Instalacion-Netbeans-Mac.pdf

• Con este ejercicio hemos instalado el IDE de Netbeans.
• Como hemos comentado el alumno puede utilizar cualquier

IDE Java de su preferencia.
• Recordemos que un IDE (Integrated Development

Environment) es sólo una herramienta, y como tal nos debe
facilitar la tarea, así que cualquier IDE soporta las tareas que
vamos a utilizar a lo largo del curso.


En este ejercicio es crear nuestro primer programa con Java. Al
finalizar deberemos observar la siguiente pantalla:

Creamos el proyecto HolaMundo:

( )
Creamos el proyecto HolaMundo:

( )
La primera vez que crea un proyecto de este tipo se activarán
las características:

( )
Nombramos el proyecto y lo agregamos en una carpeta por. Ej.
C:\Cursos\FundamentosJava:

( )
Así debe visualizarse el proyecto creado:

Archivo HolaMundo.java:
package holamundo;
public class HolaMundo {
public static void main(String[] args) {

System.out.println("Hola Mundo con Java");
}
}

Ejecutamos nuestro proyecto. Damos click derecho -> Run:

( )
Este es el resultado de ejecutar nuestro proyecto:

• Con este ejercicio hemos creado nuestro primer programa en Java con ayuda del
IDE de Netbeans.
• Un IDE es una herramienta que nos ayudará a agilizar nuestra creación de

software con Java, sin embargo no debemos depender al 100% de este tipo de
herramientas, ya que en un trabajo muchas veces no podremos seleccionar el IDE
con el que vamos a desarrollar el código Java, y por lo tanto podemos quedarnos
sin ningún conocimiento al cambiar de IDE.
• Por este motivo nosotros aprenderemos los conceptos, los cuales se pueden
aplicar en cualquier IDE independientemente de cual sea el que utilicemos o el de
nuestra preferencia. Para ello, les proporcionaremos todo el código
completamente funcional en cualquier IDE, y así puedan usar el IDE de su
preferencia.


Sólo en caso de error al compilar el proyecto, pueden intentar borrar el cache de Netbeans, para ello buscar la
siguiente ruta del cache en su PC dependiendo del sistema operativo que tengan. Para ver la ruta del cache
de Netbeans, abrir Netbeans, ir a Help -> About

Esto nos muestra la ruta del cache según el sistema operativo que tengamos:

Una vez encontrada la ruta, eliminar la carpeta de cache. Cerrar y volver a abrir
Netbeans, y volver a intentar compilar el proyecto.
Si no funciona, desinstalar y volver a instalar Netbeans.


Curso de Fundamentos de Java
Hola, te saluda Ubaldo Acosta. Bienvenida o bienvenido nuevamente. Espero que estés listo para
comenzar con esta segunda lección.
Vamos a estudiar el tema de variables y operadores, esto es la base para el manejo de la

información al crear nuestros programas en Java.
¿Estás listo? Ok, ¡Vamos!
En Java, como en cualquier lenguaje de programación, para almacenar

información, es necesario la creación de variables, las cuales nos permitirán
almacenar datos de nuestro programa de manera temporal.
El objetivo de declarar una variable es reservar espacio de memoria

dependiendo del tipo que vayamos a utilizar.
Estas variables nos permiten también hacer programas dinámicos, por lo que
en la mayoría de los casos los valores cambiarán durante la interacción con el
usuario y el programa.
Por ejemplo, como podemos ver en la figura tenemos datos, los cuales
pueden ir cambiando a lo largo de la ejecución de nuestro programa, y
tenemos variables, que son las que permiten almacenar nuestros datos
durante la ejecución del mismo.
En Java existen distintos tipos de datos, por lo que estudiaremos a más detalle
los tipos de datos y por lo tanto los tipos de variables que necesitamos crear
para almacenar un tipo de dato específico. Así que continuemos.
Existe una clasificación amplia respecto a los tipos que se manejan en Java, sin
embargo podemos resumirla en la figura mostrada.
Por un lado tenemos los tipos primitivos y por otro lado tenemos los tipos que
se consideran como extensiones de la clase Object, también conocidos como
referencia a objetos.
Respecto a los tipos primitivos podemos clasificarlos en tipos Enteros y
Flotantes, sin embargo tenemos también el tipo boolean, cada uno de estos
tipos los veremos a más detalle a continuación.
Por el contrario, tenemos los tipos Object, los cuales pueden ser Clases,
Interfaces o Arreglos (Arrays) en Java. Estos tipos los estudiaremos en el tema
de Clases y Objetos en Java, así que de momento nos enfocaremos en los
tipos primitivos y la forma en cómo declararlos y usar este tipo de datos en
Java.
Como comentamos anteriormente, tenemos distintos tipos de datos en Java, en total son 8.
Por un lado tenemos los tipos enteros, entre los cuales tenemos el tipo byte el cual ocupa 8 bits.
Posteriormente tenemos el tipo short, el cual ocupa 16 bits. También tenemos el tipo char, el cual ocupa
16 bits pero maneja el código UNICODE para almacenar valores tipo char. A su vez tenemos el tipo int el
cual ocupa 32 bits, y finalmente el tipo long el cual ocupa 64 bits.
Por otro lado tenemos los tipos flotantes, por un lado el tipo float el cual ocupa 32 bits, y el tipo double
que ocupa 64 bits. El tipo boolean en Java también es un tipo primitivo y puede almacenar sólo el valor de
true o false. Su valor por default es false.
Estos tipos de Java son los mas básicos y son los que utilizaremos si necesitamos la mayor rapidez y ahorro
en recursos, con el objetivo de que nuestros algoritmos sean lo más eficientes. Sin embargo en la práctica
utilizaremos también funciones ya creadas que pueden hacer uso de manera indirecta de estos tipos
primitivos, así que de cualquier manera los estaremos manejando en nuestros programas, ya sea de
manera directa o indirecta.
Cada uno de estos tipos primitivos, tiene un valor por default, el cual es importante conocer ya que cuando
los utilicemos en conjunto con nuestras clases de Java, el compilador tomará en cuenta este valor por
default según el tipo de dato que utilicemos.
En la figura podemos observar tanto el número de bits que ocupa cada dato, así como los valores por
default que se asignan a cada tipo cuando son utilizados como atributos de nuestras clases en Java.
Más adelante crearemos varios ejercicios para poner en práctica el uso de tipos primitivos en Java.
En Java el manejo de cadenas es un tipo Object, pero que tiene varias características en particular. Aunque aún no
detallaremos aún el manejo de objetos, pero cabe mencionar que en Java es necesario el uso del operador new para
crear un nuevo objeto.
Sin embargo cuando hablamos de cadenas esto no es necesario. Podemos simplemente declarar un tipo String y
asignar un valor cadena directamente a esta variable, es por ello que pareciera que el tipo String es un tipo primitivo
pero no es así, sin embargo debido al uso tan frecuente de este tipo al momento de estar programando, es que se
decidió simplificar el proceso de creación y asignación de valores en este tipo String en particular. Ejemplo:
String saludo = "Hola Mundo";
Podemos observar que para declarar una cadena en Java, únicamente basta con utilizar el tipo String, posteriormente
definir su nombre (identificador), y finalmente asignar un valor, sin la necesidad de utilizar el operador new. Así,
podemos asignar directamente el valor de una cadena, simplemente utilizando comillas dobles para envolver el valor
deseado.
En Java, a diferencia de otros lenguajes, no se permite la sobrecarga de operadores, lo que significa que no podemos
alterar la función de los operadores para hacer lo que nosotros deseemos, sin embargo existe una excepción a esta
regla cuando manejamos tipos cadena. Cuando usamos el operador + y se detecta un tipo String en la operación, se
dice que tenemos el contexto String, y por lo tanto en lugar de sumar valores, lo que hace Java es concatenar los
valores que se encuentren en la operación. Esto lo veremos más adelante con un ejercicio, pero es importante notar
este punto ya que es otra simplificación importante al momento de usar cadenas en Java.
Una de los detalles más importantes que estudiaremos más adelante, es la forma en que se comparan objetos en
Java, sin embargo en esta sección sólo aclararemos que al utilizar objetos no se utiliza el símbolo == como con los
tipos primitivos, sino el método equals(). En el caso de cadenas esto nos permitirá comparar el contenido de la
cadena. En el tema de objetos estudiaremos esto a más detalle, pero de momento es importante que conozcan este
detalle para que sepan cómo comparar cadenas.
En la tabla mostrada, podemos observar los caracteres de escape que son utilizados al momento
de desplegar mensajes en la salida estándar. Estos caracteres los pondremos en práctica en los
ejercicios que vamos a realizar a continuación.
Además agregamos nuevos cursos para que continúes con tu preparación como programador Java
profesional. A continuación te presentamos nuestro listado de cursos:

Struts Framework Datos de Contacto:HTML5 y CSS3

Crear un programa para practicar la creación de variables en
Java. Al finalizar deberemos observar lo siguiente:

Vamos a crear el proyecto ManejoVariables:

( )

( )

Agregamos una clase main al proyecto:

( )
Agregamos una clase main al proyecto:

Archivo ManejoVariablesTest.java:
char ch1 = 65, ch2 = 'A';
//Variables boolean, declaracion System.out.println("Valor char1:" + ch1);
boolean bool1; System.out.println("Valor char2:" + ch2);
//inicializacion System.out.println("");
bool1 = true;
//Declaracion e inicializacion //Variable enteras
boolean bool2= false; int decimal = 100;
System.out.println("Valor bool1:" + bool1); int octal = 0144;//Valor octal inicia con 0
System.out.println("Valor bool2:" + bool2); int hexa = 0x64;//Valor hexadecimal onicia con 0x
System.out.println(""); System.out.println("Valor int decimal:" + decimal);
System.out.println("Valor int octal:" + octal);
//Variables byte System.out.println("Valor int hexadecimal:" + hexa);
byte b1 = 10; System.out.println();
//Literal en hexadecimal
byte b2= 0xa; //Variables long
System.out.println("Valor byte1:" + b1); long long1 = 10, long2 = 20L;
System.out.println("Valor byte2:" + b2); System.out.println("Valor long1:" + long1);
System.out.println(""); System.out.println("Valor long2:" + long2);
System.out.println();
//Variables short
short s1 = 2; //Variables float
System.out.println("Valor char1:" + s1); float f1=15, f2=22.3F;
System.out.println(""); System.out.println("Valor float1:" + f1);
System.out.println("Valor float2:" + f2);
//Variable char, declaracion e inicializacion en una sola linea System.out.println();
//La primera declaración es en UNICODE
//http://www.icursos.net/referencias/TablaUnicode.html //Variables double
double d1=11.0, d2=30.15D;
System.out.println("Valor long1:" + d1);
System.out.println("Valor long2:" + d2);
System.out.println();

El resultado es como sigue:

• Probar creando más variables y verificar el resultado.
• Probar con el modo debug del IDE y verificar la inicialización,

asignación e impresión de cada variable creada.

• Con este ejercicio hemos puesto en práctica la creación de
variables, las cuales son la base para almacenar la
información de manera temporal de nuestro programa.
• Para más información del tema de variables en Java, así

como sus tipos de datos, ver:
• http://docs.oracle.com/javase/tutorial/java/nutsandbolts/variables.html
• http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html


Crear un programa para practicar en manejo de cadenas en
java. Al finalizar deberemos observar lo siguiente:

Vamos a crear el proyecto ManejoCadenasBasico:

( )


( )
Así el proyecto ya tiene la estructura deseada.

Archivo ManejoCadenasBasico.java:
package variables;
public class ManejoCadenasBasico {

String nombre="Karla";
String apellido="Esparza";
System.out.println("Concatenacion:" + nombre + apellido);
System.out.println("Nueva linea: \n" + nombre + " " + apellido);
System.out.println("Tabulador: \t" + nombre + " " + apellido);
System.out.println("Retroceso:\b" + nombre + " " + apellido);
System.out.println("Retorno de carro: \r" + nombre + " " + apellido);
System.out.println("Comilla simple: \'" + nombre + " " + apellido + "\'");
System.out.println("Comilla doble: \"" + nombre + " " + apellido + "\"");
}
}


( )

• Con este ejercicio hemos puesto en práctica lo más básico
del manejo de cadenas en Java.
• El tema de manejo de cadenas lo veremos a más detalle

posteriormente, pero esto lo hemos comentado con el
objetivo de que nos empecemos a familiar con este tipo de
dato que es de los más utilizados en Java.


comenzar con esta segunda lección.
Vamos a estudiar el tema de variables y operadores, esto es la base para el manejo de la

información al crear nuestros programas en Java.
Para poder realizar cualquier tipo de calculo y/o crear nuestros algoritmos, es necesario el uso de
operadores.
En la tabla mostrada podemos observar los operadores en Java, desde operadores aritméticos, de
relación, lógicos, unitarios, a nivel bit, de asignación, condicionales, así mismo la prioridad de
cada operador, así como el orden de evaluación de cada uno.
Vamos a realizar algunos ejercicios para poner en práctica esta tabla.
Cuando trabajamos con Java, el lenguaje ha definido previamente varias palabras

que ya tienen un significado en particular para el compilador, y por lo tanto no las
podemos utilizar para nuestros propósitos de asignar un nombre a una variable.
En la figura podemos observar las palabras reservadas existentes en Java y poco a

poco iremos conociendo muchas de estas palabras y el significado de cada una de
ellas, sin embargo en esta lámina podemos ver concentradas todas ellas para
tengamos un conocimiento general de que estas palabras ya han sido reservadas
por el lenguaje Java, y así nos sirvan para una referencia futura.


Crear un programa para practicar en manejo de operadores en
java. Al finalizar deberemos observar lo siguiente:

Vamos a crear el proyecto ManejoOperadores:

( )

( )

( )

Archivo ManejoOperadoresTest.java:
System.out.println("Operadores Aritmeticos:");
int a = 1 + 2; //Preincremento/decremento (se incrementa antes de asignar el valor)
int b = a * 4; c = ++a;
int c = b / 2; //Postincremento/decremento (se incrementa despues de asignar el valor)
int d = c - a; //La siguiente vez que se evalua b, es cuando se incrementa
int e = -d; d = b++;
System.out.println("a = " + a); System.out.println("b = " + b);
System.out.println("b = " + b); System.out.println("c = " + c);
System.out.println("c = " + c); System.out.println("d = " + d);
System.out.println("d = " + d);
System.out.println("e = " + e); System.out.println("\nOperador relacional:");
//a es menor que b
System.out.println("\nOperador Módulo (residuo):"); boolean res = a < b;
System.out.println("x mod 10 = " + a % 2); System.out.println("res = " + res);
System.out.println("\nOperador Compuesto:"); System.out.println("\nOperador Ternario:");

//a = a + 4 int min = (a < b) ? a : b;
a += 2; System.out.println("min = " + min);
b -= 4;
c *= a; System.out.println("\nOperador de Asignación:");
System.out.println("a = " + a); int i, j, k;
System.out.println("b = " + b); //cadena de asignación
System.out.println("c = " + c); i = j = k = 100; // valor de x, y, and z igual a 100
System.out.println("i = " + i);
System.out.println("\nOperador Incremento:"); System.out.println("j = " + j);
//int a = a + 1; System.out.println("k = " + k);
//Puede reescribierse como
a++;
System.out.println("a = " + a);

( )

• Probar con el modo debug del IDE y verificar las operaciones
realizadas, así como la asignación e inicialización de las
variables.

• Con este ejercicio hemos puesto en práctica algunos de los
operadores más comunes en Java.
• Para más información de los operadores en Java consultar:

• http://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html
• En el siguiente ejercicio veremos el uso de precedencia de

operadores.


Crear un programa para practicar la precedencia de
operadores en java. Al finalizar deberemos observar lo
siguiente:

Vamos a crear el proyecto PrecedenciaOperadores:

( )


( )

Archivo PrecedenciaOperadoresTest.java:
System.out.println("Primer Ejemplo Procedencia Operadores");
int x = 5;
int y = 10;
int z = ++x * y--;
System.out.println("x = " + x);

System.out.println("y = " + y);
System.out.println("z = " + z);
System.out.println("Ejemplo Evaluacion");
System.out.println(4 + 5 * 6 / 3);
System.out.println((4 + 5) * (6 / 3));
System.out.println("Otro Ejemplo Evaluacion");

System.out.println(1 + 2 - 3 * 4 / 5);
System.out.println(1 + 2 - (3 * (4 / 5)));
System.out.println("\nOtro ejemplo");
//Si detecta una cadena, lo demas lo convierte en cadana
System.out.println("1 + 2 = " + 1 + 2);
//Los parentesis rompen esta regla, ya que tiene la mayor prioridad
System.out.println("(1 + 2) = " + (1 + 2));
System.out.println("\nOtro ejemplo");
//El operador + es asociativo a la izquierda
System.out.println(1 + 2 + "abc");//Detecta una operacion primero
System.out.println("abc" + 1 + 2);//Detecta una cadena primero

( )

• Probar con el modo debug del IDE y verificar las operaciones
realizadas.

• Con este ejercicio hemos puesto en práctica la precedencia
de operadores en Java.
• Para más información de los operadores en Java consultar:

• http://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html


Curso de FUNDAMENTOS DE JAVA
Hola, te saluda nuevamente Ubaldo Acosta. Espero que estés listo para comenzar con esta
lección..
Vamos a estudiar el tema de sentencias de control en Java, así como la forma en que aplicaremos
el lenguaje de programación Java para resolver los problemas que nos planteemos en este curso.
A lo largo de nuestra vida, vivimos tomando decisiones. Decisiones como ¿Cuál carrera estudiar? ¿Qué trabajo elegir?
¿Casarme o no casarme? ¿Tener hijos? ¿Comenzar a ahorrar a temprana edad? Entre muchas decisiones más.
De la misma manera, cuando estamos resolviendo un problema computacional, nos enfrentamos a la toma de
decisiones, y esto es lo que estudiaremos en esta lección.
Las decisiones existe en cualquier lenguaje de programación moderno, ya que son la base para el
flujo que definimos en la solución de un problema.
Para manejar este concepto vamos a utiliza la estructura de control if. Con esto haremos la
pregunta: si esto es verdadero, entonces haz esto.
También podemos utilizar la palabra else para que en caso de que la pregunta no sea verdadera,
entonces haga algo en caso contrario.
La estructura básica se muestra en la figura.
La estructura if/else puede combinarse para generar casos más complejos. Por ejemplo utilizando
if, else if, else if, else. La idea es poder agregar decisiones según los casos que se nos presenten al
momento de resolver un problema.
También, la estructura if/else puede tener sentencias anidadas, es decir, un if dentro de otro.
Esto lo iremos poniendo en práctica conforme avancemos en el curso.
En la figura podemos observar la sintaxis que se utiliza en Java al momento de utilizar la

estructura if /else.
Para iniciar se evalúa una condición. Si esta es verdadera entonces se ejecutan las instrucciones
contenidas en ese bloque de código. Un bloque de código en la estructura if puede llevar
corchetes o no ( { … } ), esto con el fin de delimitar las sentencias o instrucciones que debe
ejecutar el if. En el caso de que no se usen corchetes, entonces sólo se podrá agregar una
instrucción después de la palabra if, como sigue a continuación:
if( condicion )
//Sólo una sentencia si no se usan corchetes
else
//Sólo una sentencia si no se usan corchetes
Además, la sección del else es opcional, pudiendo tener solo la parte del if para ejecutar la lógica
deseada.
Podemos observar en la figura la sintaxis más común al momento de utilizar la estructura if/else,
y más adelante haremos algunos ejercicios para poner en práctica esta sintaxis.
Otra forma de tomar decisiones es utilizando la estructura de control switch, que como su
nombre lo indica, es como utilizar un interruptor.
A diferencia de la estructura if/else, la estructura switch la vamos a utilizar más cuando tenemos
por ejemplo un menu de opciones. Por ejemplo, si tenemos 5 opciones, y cada una de ellas
realiza una acción distinta, entonces, la estructura switch es ideal para manejar estas decisiones.
La estructura switch es menos utilizada que la estructura de control if/else, sin embargo nos
servirá para cuestiones más especificas a la hora de tomar decisiones como veremos en el
siguiente ejemplo.
Podemos observar la sintaxis de la estructura switch. En las versiones anteriores al jdk 7, sólo se
soportaba valores en la expresión a evaluar de tipo byte, short, int o char, y de la versión jdk 7 en
adelante, se soporta también el tipo String, que aunque no es un tipo primitivo, es uno de los
tipos Object que más utilizaremos.
Una vez que comienza la evaluación de cada uno de los casos (case), pueden incluirse uno o más
casos separados por coma. Ej.
switch (expresion) {
case valor1: case valor2: case valor3:
//Sentencias
break;
case valorN:
//Setencias
break;
default:
//Setencias
}
La palabra break se utiliza para que el flujo se detenta y termine la evaluación de los demás casos,
si no lo colocamos se seguirá la evaluación de cada caso. Por último, la palabra default se utiliza
para ejecutar un bloque de código, si ninguno de los casos coincidió en su evaluación.
Además de los operadores ya mencionados, utilizaremos operadores lógicos para que en

combinación con las estructuras de control podamos crear decisiones que brinden una solución a
nuestras necesidades.
En la tabla pueden observar los operadores lógicos con los que vamos a estar trabajando.
A menos que deseemos trabajar con bits (unos y ceros), normalmente utilizaremos los
operadores AND y OR en modo corto circuito. En la siguiente tabla explicaremos qué significa
esto.
En la figura podemos observar la aplicación de los operadores lógicos y la tabla de verdad que
aplica a cada operador. Esta tabla debemos conocerla de memoria ya que es la que estaremos
aplicando cuando utilicemos los operadores lógicos. El 1 significa verdadero y el 0 significa falso.
Sin embargo no es difícil de memorizar. Lo único que tenemos que aplicar es lo siguiente.
En el caso del operador and (&&), el resultado será verdadero únicamente si ambos valores son
verdaderos, de lo contrario el resultado final será falso.
En el caso del operador or (||), el resultado será verdadero si cualquiera de los operandos (x o y)
es verdadero.
Anteriormente mencionamos los operadores AND y OR corto circuito. Lo que significa es que si se
detecta que el resultado ya no tiene sentido evaluarlo, por ejemplo si el operador && la
evaluación del operando del lado izquierdo es falso, entonces toda la expresión será falsa y ya no
se evalúa el operando restante. Y en el caso del operador || si el operando del lado izquierdo
entonces el resultado es verdadero y por lo tanto ya no se evalúa el otro operando del lado
derecho.
Y en el caso de operador de negación lo único que hace es invertir el valor original del operando.
Así que será muy sencillo aplica esta tabla de verdad por cada uno de los operadores si aplicamos
las reglas descritas. En los próximos ejercicios prondremos en práctica este tipo de operadores en
combinación con las estructuras de control.
Al utilizar las estructuras de decisión, nos encontraremos con la necesidad de comparar valores.
Es por ello que utilizaremos distintos tipos de operadores para esto.
Los operadores relacionales se enlistan en la lámina. Y los pondremos en práctica en combinación

con las estructuras de decisión en los siguientes ejercicios.


/

Crear un programa para poner en práctica el uso de la
estructura if/else. Al finalizar deberemos observar lo siguiente:

Vamos a crear el proyecto EjemploIf:

( )


( )

Archivo EjemploIf.java:
package sentenciascontrol;
public class EjemploIf {

//Ejemplo If
int x = 10;
if (x < 20) {
System.out.print("X menos que 20\n");
}
}
}


( )

Vamos a crear el proyecto EjemploIfElse:

Archivo EjemploIfElse.java:
public class EjemploIfElse {

//Ejemplo If/Else
int x = 30;
if (x < 20) {
System.out.print("X menos que 20\n");
} else {
System.out.print("X mayor que 20\n");
}
}
}


( )

Vamos a crear el proyecto EjemploIfElseIfElse:

Archivo EjemploIfElseIfElse.java:
public class EjemploIfElseIfElse {

//Ejemplo If/Else If/Else
int x = 10;
if (x == 10) {
System.out.print("X igual a 10\n");
} else if (x == 20) {
} else if (x == 30) {
} else {
System.out.print("X no es igual ni a 10, ni 20 ni 30\n");
}
}
}


( )

• Probar con el modo debug del IDE y verificar paso a paso.
• Probar con distintos valores y verificar el resultado.

• Con este ejercicio hemos puesto en práctica el manejo de las
sentencias if, else if y else.
• A continuación realizaremos algunos ejercicios más

respecto al tema de sentencias de control.


www.globalmentoring.com.mx
Crear un ejercicio de la estrucutra if/else. Al finalizar
deberemos observar lo siguiente:
Vamos a crear el proyecto CalculaMes:
( )
( )
Archivo CalculaMes.java:
package calculames;
public class CalculaMes {

int mes = 1; // Mes del año
String estacion;
if (mes == 1 || mes == 2 || mes == 12) {

estacion = "Invierno";
} else if (mes == 3 || mes == 4 || mes == 5) {
estacion = "Primavera";
estacion = "Verano";
estacion = "Otoño";
} else {
estacion = "Mes incorrecto";
}
System.out.println("La estacion para el mes " + mes + " es: " + estacion);
}
}
( )
• Con este ejercicio hemos puesto en práctica el manejo de la
estructura if.
• A continuación pondremos en práctica la estructura switch

en Java.
Crear un ejercicio de la estrucutra switch. Al finalizar

Vamos a crear el proyecto CalculaMesSwitch:

( )


( )

Archivo CalculaMesSwitch.java:
public class CalculaMesSwitch {

int mes = 4; // Mes del año
String estacion;
String saludo = "Hola Mundo";
switch(mes){
case 1:case 2: case 12:
estacion = "Invierno";
break;
case 3: case 4: case 5:
estacion = "Primavera";
break;
case 6: case 7: case 8:
estacion = "Verano";
break;
case 9: case 10 : case 11:
estacion = "Otoño";
break;
default:
estacion = "Mes incorrecto";
}
System.out.println("La estacion para el mes " + mes + " es: " + estacion);
}
}

( )


• Con este ejercicio hemos puesto en práctica el manejo de la
estructura switch.
• Con esto concluimos el tema de estructuras de control.


lección.
Vamos a estudiar el tema de ciclos en Java.
Los ciclos nos permitirán repetir un conjunto de instrucciones una cierta cantidad de
veces. Esto va a depender de una condición, la cual debemos controlar para poder
detener en algún momento el ciclo, de lo contrario podríamos terminar ejecutando un
ciclo infinito, y por consiguiente bloquear la ejecución del equipo o dispositivo que
ejecuta dicho ciclo.
La condición a cumplirse puede ser determinada por el usuario o por el programa, según
la lógica que se haya establecido.
Vamos a ver a continuación en los elementos de un ciclo.
Como hemos comentado, un ciclo podemos definirlo como una estructura que nos permite repetir o iterar
un conjunto de instrucciones o sentencias. Como podemos observar en la figura tenemos los siguientes
elementos:
1) Inicio del ciclo,

2) Condición a cumplirse, pudiendo ser cierta o falta.
3) La sentencia o sentencias a ejecutarse.
4) La evaluación nuevamente de la condición. Y se repite el ciclo si la condición nuevamente fue
verdadera, de lo contrario concluye el mismo.
Además, podemos observar las siguientes características:
a. El conjunto de instrucciones debe ser finito.

b. La cantidad de veces que se repita dicho conjunto de instrucciones también debe ser finita. En
algunos casos esta cantidad de veces va a depender de una condición explícita y en otros
casos va a depender de una condición implícita. Una condición es explícita cuando depende
solamente de la misma ejecución del programa sin que sea importante la participación del
usuario. Asimismo una condición es implícita cuando depende solamente de la voluntad del
usuario y por lo tanto la cantidad de iteraciones o repeticiones del ciclo podría variar dependiendo de la
decisión final del usuario.
c. Dentro de un ciclo podrá ir cualquier sentencia, incluyendo otros ciclos (a esto se le conoce como ciclos
anidados)
Existen distintos tipos de ciclos como son el ciclo while, do-while y for, a continuación veremos más en
detalle cada uno.
El ciclo while en Java, es el más fundamental para realizar iteraciones. Básicamente como podemos
observar en la figura, se ejecuta un bloque de código tantas veces como la condición que se evalúa sea
verdadera.
Una vez que esta condición es falsa, entonces se termina la iteración.
La expresión a evaluar puede ser cualquier valor de tipo boolean.
En Java, si vamos a utilizar el ciclo while y repetir solo una línea de código, no es obligatorio que lleve
llaves. Ej.
while( condicion )
//Sentencia unica
Pero si el ciclo while va a ejecutar más de una sentencia de código, entonces debe llevar llaves. Ej:
while (condicion ){
//Sentecia 1
//Setencia 2
//etc
}
Debido a que la condición del ciclo while se evalúa al inicio, el bloque de código a repetir no se ejecutará ni
una sola vez si es que esta condición no se cumple. Para ello existe el ciclo do-while que veremos a
continuación.
En los ejercicios que vamos a desarrollar más adelante pondremos en práctica el ciclo while.
En algunas ocasiones es deseable que el código a repetir se pueda ejecutar por lo menos una vez antes de
terminar el ciclo. Para ello se ha creado el ciclo do-while.
En pocas palabras, en ocasiones es deseable evaluar la condición al final del loop en lugar de al inicio.
Debido a esto este ciclo evalúa el código a repetir por lo menos una vez. Y en cada iteración, primero se
ejecuta el código a repetir, y después se evalúa la condición para saber si el ciclo continúa o no.
Veamos ahora su sintaxis.
El ciclo do while en Java en caso de que sólo lleve una línea de código a repetir no es obligatorio que lleve
llaves. Ej.
do
System.out.println("Sentecia a repetir");
while (condicion);
//Termina el ciclo
Pero si el ciclo while va a ejecutar más de una sentencia de código, entonces debe llevar llaves. Ej:
do{
System.out.println("Sentecia 1");
System.out.println("Sentecia 2");
System.out.println("Sentecia n");
}while (condicion);
//Termina el ciclo
Como podemos observar, debido a que la condición del ciclo do while se evalúa al final, el bloque de
código a repetir se ejecutará por lo menos una vez, aunque esta condición no sea verdadera..
En los ejercicios que vamos a desarrollar más adelante pondremos en práctica este ciclo.
Existen dos formas de crear el ciclo for en Java a partir del JDK 5. Revisaremos ambas. En la figura
podemos observar la estructura clásica del ciclo for.
El ciclo for ya tiene predefinidas secciones, las cuales son:

1) Inicialización
2) Revisión de Condición
3) Ejecución del cuerpo del loop
4) Incremento o decremento
Esto es así debido a que cuando manejamos ciclos, muchas veces utilizaremos el concepto de contador
para incrementarlo o decrementarlo según el número de iteraciones que necesitemos.
A diferencia del ciclo while o do while, en los cuales nosotros debemos tener control del momento en que
la condición ya no deba cumplirse y así evitar ciclos infinitos, en el ciclo for, tenemos secciones ya definidas
para tener un mayor control de esta variable contador o variables contadores que nos permitirán llegar a
un punto donde la condición ya no sea verdadera, y por lo tanto concluya el ciclo. De lo contrario, si no
llegáramos a un punto donde la condición es falsa, tendríamos un ciclo infinito y esto bloquearía nuestro
programa y los recursos de nuestro equipo.
Veamos ahora su sintaxis.
El ciclo for en Java en caso de que sólo lleve una línea de código a repetir no es obligatorio que lleve llaves. Ej.
for (int i = 0; i < 10; i++)

System.out.println("valor i =" + i
//Termina el ciclo
Pero si el ciclo for va a ejecutar más de una sentencia de código, entonces debe llevar llaves. Ej:
for (int i = 0; i < 10; i++) {

System.out.println("valor i =" + i);
System.out.println("otra sentencia mas");
}//Termina el ciclo
Como podemos observar, a diferencia del ciclo while o do-while, el ciclo for se forma de 3 elementos (inicialización, evaluación de
condición e incremento/decremento), además del cuerpo del ciclo for, que se repetirá mientras sea verdadera la condición.
Aquí es importante notar el orden en que se ejecutan los pasos:

1) Se inicializan las variables de control (también conocidas como contadores).
2) Se revisa si la condición es verdadera, si es así se ejecuta el bloque del ciclo. Si es falsa la condición, termina el ciclo.
3) Si la condición fue verdadera, se incrementa o decrementa la variable de control. Este elemento, llamado iteración, controla
la forma en que el loop progresa, y normalmente aprovechamos este elemento para incrementar o decrementar nuestro
contador.
4) Se vuelve a revisar la condición, si es verdadera se repiten los pasos del 2 al 4. Si la condición es falsa, concluye el ciclo.
En los ejercicios que vamos a desarrollar más adelante pondremos en práctica este ciclo.
Fundamentos de Java Hibernate Framework


Crear un ejercicio del ciclo while. Al finalizar deberemos
observar lo siguiente:

Vamos a crear el proyecto CicloWhile:

( )


( )

Archivo CicloWhile.java:
package ciclos;
public class CicloWhile {
int contador = 0;
int limite = 10;
while (contador < limite) {
System.out.println("contador = " + contador);
contador++;
}
}
}


( )

Creamos ahora una segunda versión del ejercicio:

( )
Creamos ahora una segunda versión del ejercicio:

Archivo CicloWhileV2.java:
package ciclos;
import java.util.Scanner;
public class CicloWhileV2 {

System.out.println("Por favor introduce el número de elementos a iterar:");
int maxElementos;
Scanner entradaEscaner = new Scanner(System.in); //Creacion de objeto Scanner para leer datos
maxElementos = entradaEscaner.nextInt(); //Leemos el valor proporcionado por el usuario
int contador = 0;//Inicializamos el contador
while (contador < maxElementos) {
contador++;
}
}
}


( )

• Probar ambas versiones del ciclo while con distintos valores

y verificar el resultado.

• Con este ejercicio hemos puesto en práctica el manejo del
ciclo while.
• El ciclo while como pudimos observar, podemos repetir

instrucciones, sin embargo necesitamos tener control de la
expresión a evaluar, así como del contador si lo estamos
utilizando, esto para evitar ciclos infinitos.


Crear un ejercicio del ciclo do-while. Al finalizar deberemos

Vamos a crear el proyecto CicloDoWhile:

( )


( )

Archivo CicloDoWhile.java:
package ciclos;
public class CicloDoWhile {

int contador = 0;
int limite = 10;
do{
contador++;
}
while (contador < limite);
}
}


( )

• Crear la versión 2 de este ejercicio (basarse en el ejercicio

CicloWhileV2), y probar con distintos valores.

• Con este ejercicio hemos puesto en práctica el manejo del
ciclo do while.
• El ciclo do while, a diferencia del ciclo while, podemos

repetir instrucciones, al menos una vez, incluso si la
condición a comprobar es falsa, esto se debe a que la
expresión se evalúa después de que se ejecuta el cuerpo del
bloque loop.


Crear un ejercicio del ciclo for. Al finalizar deberemos observar
lo siguiente:

Vamos a crear el proyecto CicloFor:

( )


( )

Archivo CicloFor.java:
package ciclos;
public class CicloFor {

int limite = 10;
for (int contador = 0; contador < limite; contador++) {
}
}
}


( )

• Crear la versión 2 de este ejercicio (basarse en el ejercicio

CicloWhileV2), y probar con distintos valores.

• Con este ejercicio hemos puesto en práctica el manejo del ciclo
for.
• El ciclo for, a diferencia del ciclo while, podemos observar que

tiene secciones ya definidas para facilitar la inicialización y el
incremento para el contador y así facilitar el progreso del ciclo for.
• De esta manera, si necesitamos un código más compacto podemos

preferir un ciclo for, en lugar del ciclo while, por que el ciclo while
requiere más control de nuestra parte para evitar ciclos infinitos.


comenzar con esta lección.
Vamos a estudiar el tema de Clases y Objetos, esto es la base de la programación orientada a

objetos.
En Java el concepto de Clases es fundamental para poder manejar este lenguaje de manera
adecuada, ya que es el fundamento de este increíble lenguaje de programación.
Una clase define la naturaleza de un objeto, por lo tanto una clase provee las bases de la
programación orientada a objetos. Así que cualquier concepto que se vaya a implementar en Java
está envuelto en una clase. En este capitulo veremos como crear una clase y a su vez cómo
podemos crear objetos a partir de nuestra clase.
Hemos utilizado las clases desde el inicio del curso, pero hasta ahora es que explicaremos este
concepto. Hasta el momento las clases que hemos creado has sido creadas con el único objetivo
de encapsular el método main y poder ejecutar nuestros programas. Sin embargo empezaremos a
ver en qué consiste una clase y cómo podemos beneficiarnos de este paradigma de Programación
Orientado a Objetos, también conocido como POO.
Quizá uno de los punto más importantes a entender es que una clase genera un nuevo tipo de
datos en Java. Una vez definido este tipo de datos, entonces lo podemos utilizar para crear
objetos del tipo previamente definido. Por lo tanto una clase es una plantilla para poder crear
objetos. Debido a que un objeto es una instancia de una clase, normalmente utilizaremos
“objeto” o “instancia de una clase” de manera equivalente.
Por ejemplo, podemos observar en la figura una plantilla de una Persona, esta persona puede
tener atributos (nombre, género, ocupación, etc), y métodos para ejecutar las acciones que
puede realizar esta persona (comer, dormir, brincar, etc). A continuación veremos como definir
estos elementos de una clase a más detalle.
Recordemos rápidamente que los tipos en Java, además de tener tipos primitivos, también
existen tipos referenciados. Estos tipos pueden provenir de Clases, Interfaces o Arreglos. En esta
lección estudiaremos los tipos Object que son instancia de una clase, y posteriormente
estudiaremos los tipos Interface y Arreglos.
En la lámina podemos ver la estructura general de una clase en Java. Como hemos comentado una Clase es una
plantilla o molde, de la cual podremos generar objetos (instancias) para que puedan ser finalmente utilizados estos
nuevos tipos de datos en nuestros programas.
Existen mas variantes, pero en esta lámina vamos a simplificar la creación de una clase, para que tengamos una idea
más concreta de lo que es y cómo podemos empezar a trabajar con ellas. Vamos a ver los pasos generales para crear
una clase:
1) Definir el nombre de la clase, anteponiendo la palabra reservada class. Esta clase se debe guardar en un archivo
con el mismo nombre (recordar que Java es sensible a mayúsculas y minúsculas) con la extensión .java
2) Definir los atributos o variables de nuestra clase. A esto se le conoce como variables de instancia de nuestra
clase.
3) Definir los métodos de nuestra clase. Los métodos son los que realmente contienen el código de nuestra clase,
es decir, la funcionalidad y objetivo de ser de nuestra clase.
Es importante decir que la definición de una clase precisamente es definir nuestra plantilla, a partir de la cual
crearemos objetos que son con los que finalmente trabajaremos en nuestra aplicación.
En muchas ocasiones cuando estamos iniciando el proceso de creación de una clase suele ser algo complicado de
entender, ya que debemos agregar variables y métodos a nuestra clase, de la cual aún no sabemos exactamente su
funcionalidad, entonces la pregunta es: ¿Debemos definir todos los atributos y/o métodos desde un inicio a nuestra
clase, o debemos esperar a que las necesidades o requerimientos vayan complementando el código de la misma?
La respuesta a esta pregunta depende en muchas ocasiones de la metodología de desarrollo de software que
estemos utilizando, pero en general, agregaremos los métodos que surjan del análisis de nuestro sistema. Así que
posiblemente la clase tendrá más métodos y atributos que vayamos a utilizar en un inicio, pero nuestra clase o
plantilla estará lista para soportar futuros cambios en nuestro sistema. Por ello es que en ocasiones encontraremos
atributos o métodos en nuestras clases que son poco o nunca utilizados al momento de crear los objetos de dichas
plantillas. Más adelante veremos cómo crear objetos a partir de nuestra clase.
En la lámina podemos ver la estructura general de una clase en Java. Como hemos comentado una Clase
es una plantilla o molde, de la cual podremos generar objetos (instancias) para que puedan ser finalmente
utilizados estos nuevos tipos de datos en nuestros programas.
Existen mas variantes, pero en esta lámina vamos a simplificar la creación de una clase, para que tengamos
una idea más concreta de lo que es y cómo podemos empezar a trabajar con ellas. Vamos a ver los pasos
generales para crear una clase:
1) Definir el nombre de la clase, anteponiendo la palabra reservada class

2) Definir los atributos o variables de nuestra clase. A esto se le conoce como variables de instancia de
nuestra clase.
3) Definir los métodos de nuestra clase
Cada uno de estos puntos son los que estaremos estudiando y profundizando en las siguientes lecciones,
desde la creación de clases, definición de atributos de una clase, así como la creación de métodos en una
clase.
Comencemos el estudio de las clases, con la definición de una clase muy simple. Podemos observar la
definición de la clase Persona, la cual contiene 3 atributos de tipo String y sin ningún método.
Como hemos comentado, al definir esta clase, estamos creando un nuevo tipo de dato en Java. En este
caso el nuevo tipo de dato se llama Persona. Usaremos este nombre para crear objetos de tipo Persona. Es
importante recordar que al definir una clase, sólo estamos definiendo la plantilla con la que vamos a
trabajar, pero para poder usar esta plantilla necesitamos crear objetos a partir de esta plantilla. Definir la
clase no crea un objeto en automático, tenemos que crearlos. Esto es lo que veremos a continuación.

Datos de Contacto:

Crear un programa para practicar la creación de clases en Java.
Al finalizar deberemos observar lo siguiente:

Vamos a crear el proyecto CreacionClasesObjetos:

( )

( )

Agregamos una clase al proyecto:

( )
Agregamos una clase al proyecto:

Archivo Persona.java:
package personas;
public class Persona {
//Atributos de una clase

//No es necesario asignar valores
String nombre;
String apellidoPaterno;
String apellidoMaterno;
//Metodos de la clase
//Los usaran los objetos de esta clase
public void desplegarNombre() {
System.out.println("Nombre : " + nombre);
System.out.println("Apellido Paterno : " + apellidoPaterno);
System.out.println("Apellido Materno : " + apellidoMaterno);
}
}

Este proyecto aún no puede ser ejecutado, debido a que se
necesita del método main y se necesita crear un objeto de esta
clase para poder ejecutarla.
Sin embargo es importante saber que en este momento ya

hemos creado nuestra clase (nuestra plantilla) y a partir de ella
es que podremos crear objetos y asignar valores a sus
propiedades, así como hacer uso de los métodos de la clase. En
el siguiente ejercicio terminaremos este proyecto.


Vamos a estudiar el tema de Clases y Objetos, esto es la base de la programación orientada a

objetos.
Un objeto es la instancia de una clase, es decir que a partir de nuestra plantilla, es

posible crear objetos en concreto con los cuales podremos trabajar, es decir,
cambiar sus valores y llamar a sus métodos.
Más adelante veremos que hay casos en los que podremos trabajar directamente
con la clase, a esto se le llama contexto estático, pero de momento estaremos
estudiando el contexto dinámico, es decir, necesitamos crear una instancia de una
clase para poder trabajar con ellas.
Como podemos observar en la figura, tenemos la clase Persona, y a partir de esta

plantilla podemos crear objetos concretos para poder trabajar con sus
características y atributos. Por ejemplo hemos creado dos objetos de tipo Persona,
y cada uno tiene características similares pero con valores distintos.
Las características son por ejemplo: Nombre, Apellido, Color, Género, escolaridad,
etc.
Y cada uno de los objetos se les asigna estas características, de esta manera la clase
nos sirve sólo para indicar que características tendrán los objetos que vamos a
crear. Veamos ahora la sintaxis para crear un objeto.
Para definir un objeto vamos a utilizar la palabra reservada new. Esta palabra en Java significa en términos simples
que vamos a crear una nueva variable del tipo Persona. Para crear un objeto vamos a utilizar una línea de código
como sigue:
Persona p1 = new Persona();
Después de que esta línea se ejecuta, la variable p1 podrá acceder a un objeto de tipo Persona. Cada vez que se
manda llamar la palabra new se creará un nuevo objeto de tipo Persona, y contendrá sus propios valores. Por
ejemplo:
Esta nueva variable p2, apunta a un nuevo objeto de tipo Persona, y por lo tanto contendrá valores distintos a la
variable p1. Así, cada nuevo objeto contendrá valores distintos en los atributos de nombre, apellidoPaterno y
apellidoMaterno. La sintaxis new Persona() hace referencia al nombre de la clase de la cual queremos crear una
nueva instancia, es decir, un objeto. Además, estamos haciendo uso del concepto de constructor de la Clase, este
concepto lo estudiaremos más adelante, aquí solo debemos notar que para llamar al constructor de la clase se pone
el nombre de la clase y posteriormente se utilizan paréntesis, en este caso un constructor sin argumentos, pero
veremos posteriormente que podemos enviar argumentos al momento de crear un objeto.
El nombre de la variable puede ser cualquiera que elijamos, pero no debe tener caracteres especiales, o espacios.
Para acceder a los atributos de nuestras clases vamos a utilizar el operador . A través de este operador se liga el
nombre del objeto con el nombre del atributo de la clase. Por ejemplo, para asignar el valor de Armando al atributo
nombre del objeto p1, sería como sigue:
p1.nombre = "Armando";
En lecciones posteriores veremos en términos más técnicos lo que hace la palabra new, pero para esta lección es
suficiente con saber que nos permite crear nuevos objetos.
La palabra new solicita espacio de memoria de manera dinámica para poder almacenar un objeto. Con la sintaxis
generalmente como sigue:
variableQueAlmacenaReferencia = new TipoClaseAInstanciar();
En la figura podemos observar que en primer lugar declaramos una variable de tipo de la clase Persona, llamada p1.
Podemos observar que el efecto que esto tiene en la memoria Java es que se crea espacio para esta variable llamada
p1. Pero esta variable aún no tiene ningún valor asignado, ya que sólo se declaró la variable.
En la segunda sentencia, podemos observar, que además de declarar una variable de tipo Persona llamada p2, se le
asigna la referencia de un objeto de tipo Persona. Para la creación de este objeto de tipo persona se utiliza la palabra
new, seguida del nombre de la clase de la cual queremos crear el objeto y finalmente los paréntesis es el tipo de
constructor que vamos a utilizar para la creación de este objeto.
El concepto de constructor lo estudiaremos a detalle posteriormente, pero solo pensemos en el constructor como la
forma en que queremos crear nuestro objeto de manera inicial, podemos crear por ejemplo un objeto de tipo
persona ya con valores como son nombre, apellido, etc, o como en este caso, podemos simplemente crear el objeto
de tipo Persona, sin proporcionar los valores de nombre y apellido y posteriormente podremos cambiar y/o asignar
estos valores a los atributos de nuestro objeto de tipo Persona.
Debemos aclarar que los tipos primitivos como int, long, etc, no son objetos, por lo tanto para declarar variables de
estos tipos no se necesita utilizar la palabra reservada new.
Recordemos que la palabra new lo que hace internamente es solicitar espacio de memoria para la creación de un
nuevo objeto, tantos objetos como necesitemos, sin embargo, la memoria es finita, y por lo tanto podríamos recibir
un error al momento de crear demasiados objetos en tiempo de ejecución de nuestro programa. En temas
posteriores veremos el manejo de errores y como tratar los más comunes, como la falta de memoria en Java.
En conclusión, una clase define un nuevo tipo, y un objeto es una instancia de este nuevo tipo que ya se ha creado
previamente. Podemos crear tantos objetos del tipo creado como necesitemos, esto con ayuda de la palabra new.
Si recordamos en lecciones previas, mencionamos que el tipo String es una clase de Java, pero con un
tratamiento especial. Debido a que este tipo de datos se utiliza en repetidas ocasiones en nuestros
programas, es posible omitir el uso de la palabra new, y por tanto simplificar la creación de una variable de
tipo String.
Entonces podemos crear un objeto de tipo String de la manera clásica:
String nombre = new String("Armando");
Pero lo utilizaremos más comúnmente sin el uso de la palabra new, este es el método simplificado:
String nombre = "Armando";
Ambas opciones son válidas, pero utilizaremos más la segunda opción debido a que se simplifica el código.
Sólo no hay que olvidar que el tipo String es una clase y no un tipo primitivo. Este tipo de dato es la única
excepción a la regla para crear objetos utilizando el operador new. Todos las demás clases deberán utilizar
el operador new para poder crear un objeto.
Empezaremos a utilizar este tipo en nuestros siguientes ejemplos, y así familiarizarnos rápidamente con el
uso del tipo String en Java.

Datos de Contacto:

Crear varios objetos de la clase persona para practicar la
creación de objetos en Java. Al finalizar deberemos observar lo
siguiente:

Vamos a crear una clase de prueba que contenga los objetos
que vamos a crear:

( )
Vamos a crear la clase de prueba:

Archivo PersonaPrueba.java:
package personas;
public class PersonaPrueba {

public static void main(String args[]){
//Creacion de un objeto
//LLamando a un metodo del objeto creado

System.out.println("Valores por default del objeto Persona");
p1.desplegarNombre();
//Modificar valores
p1.nombre = "Juan";
p1.apellidoPaterno = "Esparza";
p1.apellidoMaterno = "Lara";
//Volvemos a llamar al metodo

System.out.println("\nNuevos valores del objeto Persona");
p1.desplegarNombre();
}
}
Ejecutamos el proyecto:

( )

• Probar con distintos valores y verificar que se asignen

correctamente los valores a cada atributo de la clase
Persona.
• Crear un segundo objeto, asignar valores distintos y

desplegar estos nuevos valores. ¿Qué sucede con los valores
del primer objeto? ¿Se modificaron o quedaron igual, siendo
que los objetos creados pertenecen a la misma plantilla?

Este proyecto hemos creado un objeto de la clase Persona.
También vimos que si no asignamos valores a los atributos de la
clase Persona, su valor es null. Esto quiere decir que no tiene
aún valor asignado.
Posteriormente asignamos valores utilizando cadenas (Strings)

y desplegamos la información a la salida estándar (consola). Así
pudimos observar los valores que tiene cada atributo.


lección.
Vamos a estudiar el tema de métodos en Java.
Como mencionamos anteriormente, una clase consiste de atributos y métodos. El tema de métodos es muy amplio, sin embargo
en esta primera introducción veremos cómo podemos crear y usar los métodos que declaremos.
Podemos observar que en Java, es necesario que para crear un método debe estar dentro de una clase. Esto se debe a que Java es
un lenguaje orientado a objetos, y por lo tanto una de las prácticas es que los métodos deben ser parte de una clase para estar
correctamente definidos.
Por otro lado, podemos observar que la definición general de un método. En primer lugar podemos observar el tipo que regresará
este método. Algunos métodos no regresan ningún valor en particular, por lo que en Java utilizaremos la palabra reservada void
para este caso donde no se regrese ningún valor. Podemos especificar tipos primitivos, o de tipo Object, incluyendo los que
nosotros creemos, como el tipo Persona que creamos anteriormente.
Posteriormente del tipo, especificamos el nombre del método, debemos recordar que Java es un lenguaje sensible a mayúsculas y
minúsculas, por lo que debemos respetar el nombre del método y usarlo tal como se escribe. Es común que el nombre del
método sea un acción, por ejemplo insertarPersona, borrarAlumno, etc. También es común en Java utilizar la notación de camello
para escribir los nombres tanto de variables como de métodos, y en general de los nombres que escribimos. Esta notación
consiste en escribir la primera letra en minúscula y posteriormente la primera letra de cada palabra debe ir en mayúscula.
Conforme avancemos iremos observando ejemplos de este tipo de notación a lo largo del curso.
Posterior al nombre, especificamos la lista de argumentos, especificando primero el tipo y posteriormente el nombre del
argumento. Por cada argumento que deseemos agregar, debemos separarlos por una coma. Si el método no tiene lista de
argumentos, sólo veremos que se abren y cierran paréntesis ( ).
Finalmente escribiremos el cuerpo del método entre llaves { }. Todo lo que escribamos dentro de estas llaves es lo que ejecutará
el método. Podemos ver el ejemplo del método sumar. En este caso debido a que el método regresa un valor, usamos la palabra
reservada return seguida del valor a regresar al método que hizo la llamada al método sumar.
Un concepto importante al definir métodos en Java, se conoce como la firma del método. En el caso del método sumar, la firma
del método sería: int sumar(int, int); //firma del método
Es decir, el método devuelve un valor entero, su nombre es sumar, y recibe dos argumentos de tipo entero. Así la firma de este
método nos indica cómo podemos utilizarlo, que valor esperar y también si debemos enviar argumentos o no, y de que tipo son
estos argumentos. Posteriormente pondremos en práctica este ejemplo.
Una vez que hemos agregado un método a una clase, podemos hacer uso de él haciendo lo siguiente:
1) Debemos declarar un objeto del tipo de la clase que tiene el método que nos interesa utilizar.
2) Por medio del objeto declarado, utilizamos el operador punto (.) y posterior a este operador
escribimos el nombre del método que nos interesa llamar. Recordemos que en Java, los nombres son
sensibles a mayúsculas y minúsculas, por lo que debemos de hacer la llamada al método tal y como lo
hayamos escrito, respetando las mayúsculas y minúsculas que hayamos utilizado para definir el
método.
3) Posterior del nombre del método, abrimos y cerramos paréntesis. Si el método no recibe ningún
argumento, solo abrimos y cerramos paréntesis, sin embargo si el método fue escrito para recibir
argumentos, debemos proporcionar los argumentos del tipo esperado, separando por comas cada uno
de ellos.
4) Finalmente, si el método fue escrito para regresar un valor, es opcional el recibirlo con una variable del
tipo que regresa el método. Debemos notar que el tipo devuelto por un método no tiene que ser igual
a los tipos de los argumentos recibidos. Para ello debemos observar la firma del método que vayamos
a utilizar. Si recordamos, la firma del método sumar sería:
int sumar(int, int); //firma del método
Por lo que observamos que el método recibo dos argumentos de tipo entero, pero podría ser cualquier
otro tipo, se llama sumar y devuelve un tipo entero, pero también podría ser cualquier otro tipo.
Posteriormente pondremos en práctica este ejemplo y varios más para que vaya quedando cada vez más
claro la declaración y uso de métodos.


Crear el ejercicio de Aritmetica. Al finalizar deberemos

Vamos a crear el proyecto Aritmetica:

( )

( )

Creamos la clase Aritmetica:

( )
Creamos la clase Aritmetica:

Archivo Aritmetica.java:
package aritmetica;
public class Aritmetica {
int sumar(int a, int b){

return a + b;
}

Creamos la clase PruebaAritmetica:

( )
Creamos la clase PruebaAritmetica:

Archivo PruebaAritmetica.java:
package aritmetica;
public class PruebaArtimetica {
//Creamos un objeto de la clase Aritmetica

Aritmetica a = new Aritmetica();
//Llamamos el metodo sumar y recibimos el valor devuelto

int resultado = a.sumar(5, 3);
System.out.println("Resultado:" + resultado);
}
}


( )


• Con este ejercicio hemos puesto en práctica el manejo de
métodos en Java.
• Como observamos un método tiene un nombre, puede

recibir argumentos de entrada, y tiene un valor de regreso.
Este es un método simple pero nos permite poner en
práctica el manejo de métodos, poco a poco iremos
agregando métodos más complejos.


lección.
Vamos a estudiar el tema de constructores en Java.
Puede ser muy tedioso estar inicializando las variables de una clase cada vez que creamos un objeto, para ello Java permite
agregar valores a los objetos desde el mismo momento de su creación. A este concepto se le conoce como Constructor, y
básicamente es un método pero que nos permitirá crear un objeto con los valores que proporcionemos al momento de crear
nuestro objeto.
Los constructores aunque son muy similares a los métodos, tienen ciertas diferencias y características, tales como:
• Estos métodos sólo se puede ejecutar al momento de la creación de un objeto, no es posible utilizarlos después.
• No devuelven ningún valor.
• El nombre del constructor es idéntico al nombre de la clase, así es como podemos identificar si una clase tiene constructores
(siempre respetando las mayúsculas y minúsculas)
• Por defecto en Java, se crea un constructor sin argumentos, conocido como constructor vacío. Este constructor lo agrega en
automático el compilador de Java a nuestra clase, sin embargo si nosotros definimos un constructor distinto al constructor
vacío, es decir, con argumentos, entonces Java ya no agrega el constructor vacío y es nuestra responsabilidad agregar el
constructor vacio a nuestra clase si fuera necesario.
• El constructor vacio es necesario para crear un objeto, recordemos la sintaxis básica general para crear un objeto.
• TipoClase objeto = new TipoClase( );
• Si observamos al final de la línea de código estamos abriendo y cerrando paréntesis, ese es precisamente el constructor vacío
que el compilador agregó por nosotros siempre y cuando no agreguemos constructores con otros argumentos. Por lo que
ahora ya podemos entender que después de la palabra new realmente lo que estamos colocando es el nombre del constructor
que deseamos llamar, pudiendo tener argumentos o no.
En la figura podemos observar un ejemplo de nuestra clase Aritmetica, usando un constructor vacio y otro no vacio para crear
nuestros objetos.
Supongamos que tenemos dos atributos en nuestra clase, de tipo entero, llamado a y b. En el primer caso estamos creando un
objeto llamando al constructor vacío, por lo tanto los valores de nuestros atributos se inicializan con los valores por default según
el tipo de cada atributo. Si es un tipo primitivo, se inicializan según su valor por default, y si son de tipo object su valor inicia es
null.
Por otro lado creamos un objeto Aritmetica pero con valores iniciales desde el momento en que estamos creando el objeto
respectivo. Estamos enviando los valores de 5 y 10 respectivamente, y por lo tanto podemos tomar estos valores para inicializar
los atributos de nuestras clases.
Como hemos comentado, un constructor inicializa un objeto al momento de la creación, además es el

encargado de reservar la memoria para la creación del objeto.
Para crear un constructor en una clase Java, la sintaxis general incluye el nombre de la clase, de esta forma
podemos identificar si una clase tiene un constructor o no. Anterior a esto puede tener o no un modificador de
acceso como public o private, estos modificadores los estudiaremos a detalle posteriormente. Después del
nombre de la clase, similar a un método, puede tener o no argumentos.
Recordemos que Java crea el constructor sin argumentos de manera automática, sin embargo si hemos
agregado un constructor con argumentos, entonces Java ya no agregará este constructor por nosotros y es
nuestra responsabilidad agregarlo si lo vamos a necesitar, de hecho por buena práctica deberíamos agregarlo
siempre que definíamos un constructor con argumentos.
En Java cuando creamos dos métodos o más con el mismo nombre, a esta característica se le conoce como
sobrecarga de métodos (overloading). Esto significa que podemos que al momento de crear un objeto tenemos
dos o más opciones para crearlo.
Como observamos en el ejemplo, hemos agregado dos constructores a la clase Aritmetica, en el primer caso es
el constructor vacio o sin argumentos. Este constructor puede tener opcionalmente un código al momento de
crear el objeto, sin importar que no reciba argumentos.
En segundo lugar, tenemos un constructor con dos argumentos, y recibe dos argumentos de tipo entero, una
vez que recibimos los argumentos, normalmente los utilizaremos para inicializar nuestros atributos de la clase.
Esto es lo que pondremos en práctica en el siguiente ejercicio.
Por último cabe mencionar que un constructor a diferencia de un método, no tiene un valor de regreso, por ello
no encontraremos la palabra return ni un tipo de retorno en la firma del constructor. Esto se debe a que lo que
regresa un constructor es el objeto en si mismo.


_

Crear el ejercicio de Aritmetica_v2. Al finalizar deberemos

Vamos a copiar el proyecto Aritmetica y a partir de este
proyecto crearemos el proyecto Aritmetica_v2:

( )
Vamos a copiar el proyecto Aritmetica para crear la v2:

Modificamos la clase Aritmetica para agregar constructores:
package aritmetica;
//Este metodo toma nuevos valores
public class Aritmetica { int sumar(int a, int b){
return a + b;
//Atributos de la clase }
int a;
int b; //Este metodo toma los atributos de la clase
int sumar(){
//Constructor Vacio return a + b;
Aritmetica(){} }
}
//Constructor con 2 argumentos
Aritmetica( int arg1 , int arg2){
a = arg1;
b = arg2;
}

Modificamos la clase PruebaAritmetica.java:
package aritmetica;
//Creamos un objeto de la clase Aritmetica con el constructor vacio

Aritmetica obj1 = new Aritmetica();
//Llamamos el metodo sumar y recibimos el valor devuelto

int resultado = obj1.sumar(5, 4);
System.out.println("Resultado suma directa obj1:" + resultado);
//Si llamamos directamente el metodo sumar sin argumentos

//el valor es cero, ya que los atributos del objeto nunca se inicializaron
//ya que no se uso el constructor con argumentos, sino el constructor vacio
System.out.println("Resultado suma atributos obj1:" + obj1.sumar() );
//Ahora creamos un objeto con el constructor con 2 argumentos

Aritmetica obj2 = new Aritmetica(2,1);
//Imprimimos directamente el resultado.

//Al llamar directamente al metodo suma, nos regresa el valor de la suma
System.out.println("\nResultado suma atributos obj2:" + obj2.sumar() );
}
} www.gl obal mentoring.com .mx

( )


• Con este ejercicio hemos puesto en práctica el manejo de
constructores en Java.
• Los Constructores nos permiten crear nuestros objetos con

valores personalizados desde el momento de la creación, de
esta manera.
• Un Constructor es un tipo de método que sólo se puede

utilizar al momento de crear un objeto y debe llamarse igual
que la clase.


lección.
En ocasiones un método necesita hacer referencia al objeto con el que estamos trabajando actualmente. Para esta tarea Java
agregó la palabra reservada this. La palabra this es un operador el cual nos permite acceder al objeto actual (la clase con la cual
estamos trabajando), y nos servirá, entre otras cosas, para acceder a los atributos o métodos de una clase. Con esto podemos
hacer una diferencia entre los argumentos recibidos en un método y los atributos de una clase.
Como podemos observar en la lámina, tenemos un código que tiene un atributo llamado a y b, y también el Constructor de la
clase recibe dos argumentos llamados a y b. Para hacer diferencia entre estas dos variables (atributos de la clase y los argumentos
recibidos en el método) podemos utilizar la palabra this como sigue:
//Constructor con 2 argumentos. Usamos el operador this
Aritmetica( int a , int b){
this.a = a;
this.b = b;
}
Como podemos observar, para hacer diferencia entre los valores recibidos en el Constructor y los atributos de la clase, podemos
utilizar el operador this. Esto es solo un ejemplo del uso del operador this, pero básicamente nos permite acceder a los atributos y
métodos del objeto actual con el cual estamos trabajando.
Esto puede ser un confuso en un inicio, ya que estamos trabajando con el código de nuestra clase, es decir, la plantilla, y este
código no se ejecutará hasta que hayamos creado un objeto y mandemos llamar este constructor, será en este momento cuando
enviemos los argumentos y el constructor los reciba y los procese. Así que debemos acostumbrarnos a pensar en dos momentos,
la creación de nuestras clases o plantillas, y la creación de nuestros objetos, que será cuando realmente se ejecute el código que
hemos programado en nuestras clases o plantillas.
Aunque el uso del operador this en ocasiones parecerá redundante, es un buena práctica el usarlo para hacer referencia a los
atributos de la clase en la que estamos trabajando, ya que al leer nuestro código rápidamente reconoceremos qué variables son
atributos de una clase y cuales no lo son.
Dentro de los constructores o métodos de una clase, el operador this hará siempre referencia al objeto que fue invocado. Si
observamos el código, tanto el argumento recibido como el atributo de la clase se llaman exactamente igual, por lo tanto toma
prioridad el argumento sobre el atributo de la clase, a esto se le conoce como ocultamiento del atributo de la clase. Y para
resolver este problema basta con utilizar el operador this antes de la variable, tal como si accediéramos al atributo de una clase
por medio del operador punto.
En Java tenemos distintos tipos de variables, como son variables de Clase y variables
Locales.
Dependiendo de dónde se defina la variable será la duración de la misma, y a esto se le

conoce como el Alcance de una Variable.
Si una variable la definimos como un atributo de una clase, esta variable se le conoce
como variable de Clase, y existirá durante todo el tiempo que exista el objeto en
memoria. Estas variables se inicializan con su valor por default de manera automática, por
ejemplo un tipo entero se inicializa con el valor de 0, una variable tipo bool con el valor de
false, y un tipo Object con el valor null.
Por otro lado, las variables locales son cualquier variable definida dentro de un método,
incluyendo los argumentos que recibe una función. Estas variables tiene un tiempo de
vida más corto, ya que se crean al momento de ejecutarse el método y se eliminan de la
memoria apenas haya terminado la ejecución de dicho método. Además las variables
locales es necesario inicializarlas con algún valor, de lo contrario el compilador marcará un
error debido a la falta de inicialización de este tipo de variables.
Las variables locales, ocultan a las variables de clase, y si queremos utilizar las variables de
clase en un método que ha definido variables locales con el mismo nombre, entonces
debemos utilizar el prefijo this para poder acceder a las variables de clase en lugar de los
atributos locales.


_

Crear el ejercicio de Aritmetica_v3. Al finalizar deberemos

Vamos a copiar el proyecto Aritmetica_v2 y a partir de este
proyecto crearemos el proyecto Aritmetica_v3:

( )
Vamos a copiar el proyecto Aritmetica para crear la v3:

Modificamos la clase Aritmetica para agregar más métodos:
package aritmetica; //Este metodo toma los atributos de la clase para
hacer la suma
public class Aritmetica { int sumar(){
return a + b;
//Atributos de la clase }
int a;
int b; //Método restar
int restar(){
//Constructor Vacio return a - b;
//Recordar que si agregamos un constructor }
distinto al vacio
//ya no se crea este constructor y //Metodo multiplicar
nosotros debemos crearlo si lo necesitamos int multiplicar(){
Aritmetica(){} return a * b;
}
//Constructor con 2 argumentos
Aritmetica( int a , int b){ //Metodo dividir
//Uso del operador this int dividir(){
this.a = a; return a / b;
this.b = b; }
} www.gl obal mentoring.com
} .mx
Modificamos la clase PruebaAritmetica.java:
package aritmetica;

//Variables locales
int operandoA = 6;
int operandoB = 2;
//Creamos un objeto de la clase Aritmetica enviando argumentos

Aritmetica obj1 = new Aritmetica(operandoA,operandoB);
//Imprimir operandos
System.out.println("Operando A:" + operandoA + " y operadoB:" + operandoB);
//Resultado de la suma
System.out.println("\nResultado suma:" + obj1.sumar() );
//Resultado de la resta
System.out.println("\nResultado resta:" + obj1.restar());
//Resultado de la multiplicacion
System.out.println("\nResultado multiplicacion:" + obj1.multiplicar());
//Resultado de la division
System.out.println("\nResultado division:" + obj1.dividir());
}
// void otroMetodo(){
//No se puede acceder a una variable local declarada en otro metodo
// System.out.println("valor operando A" + operandoA);
// }
}

( )


• Con este ejercicio hemos puesto en práctica algunos temas
como son la creación de métodos, el uso del operador this,
así como el tema de alcance de variables.
• Con estos conceptos hemos agregado algunas mejoras a

nuestra clase Aritmetica, así como algunos métodos que
complementan la funcionalidad de la clase.
• En temas posteriores seguiremos trabajando en más

conceptos sobre este mismo proyecto.


Crear un proyecto según las especificaciones mostradas a
continuación.

Vamos a construir un proyecto llamado Caja.
alto Fórmula volumen:

vol = ancho x alto x profundo
profundo
ancho
Se solicita crear una clase llamada Caja con las siguientes características:
• Debe tener 3 atributos de tipo entero (ancho, alto y profundo)

• Debe tener 2 constructores, uno vacío y uno con 3 argumentos, uno
por cada atributo de la clase.
• Debe tener el método que calcule el volumen de la caja según la
formula de la lámina anterior.
• Crear una clase de prueba para crear un objeto de tipo caja que tenga
como valores: ancho=3, alto= 2, profundo = 6 y que mande a imprimir
el volumen de la caja según los valores proporcionados
anteriormente



lección.
Como en muchos lenguajes de programación, la memoria RAM (Random Access Memory) se utiliza para
almacenar la información de nuestro programa mientras éste se ejecuta. Java ejecuta un proceso, y a su
vez internamente existen dos clasificaciones para almacenar los valores de nuestros programas, conocidos
como memoria Stack y Memoria Heap.
La memoria Stack se utiliza para almacenar las variables locales y las llamadas de funciones en Java. Las
variables almacenadas en este espacio de memoria normalmente tienen un periodo de vida corto,
únicamente mientras termina la función o método en el que se están ejecutando.
La memoria Heap se utiliza para almacenar los objetos Java, incluyendo sus atributos. Los objetos
almacenados en este espacio de memoria normalmente tienen un tiempo de duración más prolongado.
Esto quiere decir que las varibles que creamos, como podemos observar en la figura, no almacenan el
objeto en sí mismo, sino solo guarda la referencia del objeto. En la figura podemos observar que la
referencia del objeto se representa por un valor hexadecimal (0x333), el cual contiene la dirección de
memoria donde está almacenado el objeto, y por lo tanto la variable local p1 almacena únicamente esta
referencia de memoria.
Esto es muy importante para temas como la recolección de objetos en Java, debido a que el recolector de
basura únicamente podrá eliminar los objetos que no estén siendo apuntados por ninguna variable. De
esta manera el recolector de basura (garbage collector) puede buscar aquellos objetos en la memoria heap
que ya no estén siendo referenciados por ninguna otra variable y finalmente liberar el espacio en memoria
que ocupaba dicho objeto.
Con esto podemos agregar otra importante distinción entre clase y objeto. Una clase define un tipo para
ser posteriormente instanciado, es decir, con el objetivo de crear objetos. Esto quiere decir que un objeto
ocupa un espacio real en memoria, y son los objetos los que utilizaremos en la mayoría de nuestros
programas para enviar y recibir mensajes mediante el uso de sus métodos.
A diferencia de lo que pudiéramos pensar, en Java una variable de tipo Object únicamente almacena una referencia a
los objetos que son creados, por lo que le segunda línea del código mostrado, únicamente lo que hace es pasar la
referencia que está almacenando la variable p1. Y por lo tanto ahora son dos variables las que están apuntando al
mismo objeto, es decir, que ambas variables podrán acceder a lo que el objeto permita según la clase definida, por
ejemplo sus atributos o métodos que haya definido.
Es importante observar que no se está creando un segundo objeto, ya que solamente hay una llamada de la palabra
new, y por lo tanto solo hay un objeto creado. Lo que almacena la variable p2 es sólo el valor de la referencia en
memoria del objeto Persona creado. Cada que utilizamos la palabra new recibiremos una nueva referencia de
memoria, es importante notar esto, ya que hasta ese momento es que se creará un nuevo objeto y no antes.
Si ejecutáramos la siguiente línea:

p1 = null;
Lo que sucedería es que la variable p1 ya no tendría la referencia del objeto Persona creado ubicado en la referencia
0x333, y por lo tanto sólo la variable p2 es la que podría seguir accediendo a este objeto creado.
Si ejecutáramos finalmente:
p2 = null;
Lo que sucedería es que p2 ya no tendría más la referencia del objeto y por lo tanto ninguna variable tendría la
referencia del objeto Persona creado, y por lo tanto el recolector de basura de Java podría disponer de este objeto y
eliminarlo de la memoria. Un objeto es candidato a eliminarse de la memoria hasta que ninguna variable este
apuntando al objeto, es decir, que ninguna variable contenga su referencia.
El proceso de recolector de basura es un proceso que demanda muchos recursos, por lo que llamara a System.gc() no
garantiza que se ejecute el recolector de basura (garbage collector). Sin embargo con la llamada a esta función le
estamos indicando a Java que en cuanto sea posible ejecute el recolector y por tanto elimine los objetos de memoria
que ya no están siendo utilizados, es decir, que ya no existe ninguna variable apuntando a estos objetos.


lección.
Hasta ahora hemos utilizado tipos primitivos al enviar valores a nuestros métodos,
esto se conoce como paso por valor, ya que como vimos en lecciones anteriores,
sólo estamos copiando el valor del tipo primitivo, pero cada variable contiene su
propia copia.
Por ejemplo en el código mostrado podemos observar un ejemplo de paso por

valor, también conocido como valores de tipo primitivo. Lo que observamos en el
código es que al crear una variable, en este caso x, y asignarle un valor, por ejemplo
10, esta variable al ser modificada en otro método su valor original no se ve
modificado, ya que solamente paso una copia de su valor original.
La manera de cambiar el valor de la variable x sería cambiándolo dentro del mismo

método. Sin embargo en este ejemplo el método llamado cambiarValor intenta
realizar un cambio a la variable x, pero como está fuera del alcance de este método
acceder a esta variable, únicamente puede cambiar el valor de su variable local
llamada i. Y al cambiar el valor de esta variable y regresar al método que hizo la
llamada original
Además del paso por valores, en Java tenemos el paso por referencia, esto básicamente que utilizaremos objetos como
parámetros en lugar de tipos primitivos. Al utilizar un objeto como parámetro y enviarlo a un argumento de un método
lo que estamos haciendo es enviando la referencia del objeto que se está deseando utilizar, y en lugar de utilizar una
copia del valor del objeto, lo que realmente estamos haciendo es apuntar al mismo objeto, con la finalidad de
modificarlo directamente, sin necesidad de hacer una copia.
Esto se debe a que imaginemos que un objeto contiene 50 atributos o más, y si se realizar una copia del objeto, lo que
estaríamos generando realmente es una copia de estos 50 valores. Por ello, cuando trabajamos con objetos, y los
enviamos como argumentos a un método, sólo estamos enviando el valor de la referencia donde se ubica este objeto,
de tal manera que podemos modificar directamente el objeto, ya sea desde la variable original que apunta al objeto, o
desde la variable local que funciona como argumento en la llamada del método.
En el código podemos observar la variable p de tipo Persona, esta clase la crearemos en la sección de ejercicios, pero
básicamente tiene un atributo llamado nombre de tipo String, y lo que podemos observar es que se modifica el valor
del atributo nombre, esto debido a que la variable local llamada arg apunta al mismo objeto creado en la memoria
Heap de tipo Persona, y por lo tanto al modificar el atributo del mismo objeto, entonces se modifica el objeto creado
originalmente, y podemos acceder a este cambio incluso desde otros métodos.
Esto trae lugar a discusiones, ya que se dice que Java únicamente pasa parámetros por valor, y no por referencia, y de
alguna manera es cierto, ya que como podemos observar en la memoria stack, el valor de p se “Copia” a la variable arg
al llamar al método modificarPersona, pero debido a que lo que recibe arg es la dirección de memoria del objeto
Persona creado originalmente, entonces la variable arg puede acceder a los atributos y métodos del objeto p, y de esta
manera es que es posible modificar el estado o contenido del objeto original. Y al terminar de ejecutar el método
modificarPersona y regresar al método main es posible acceder a estos cambios, y en lugar de mandar a imprimir Juan
que era el nombre original, se manda a imprimir el valor de Carlos, que es el valor modificado por la variable arg.
De esta manera podemos observar como en Java cuando trabajamos con objetos, realmente lo que estamos
proporcionando es el valor de la referencia de memoria, en este caso el valor de 0x333, y con esta referencia
accedemos directamente al objeto, y así podemos modificarlo. Finalmente estas modificaciones las podremos acceder
incluso fuera del método donde fue creado originalmente el objeto, o desde el método donde se creó dicho objeto.


Crear el ejercicio PasoPorValor. Al finalizar deberemos

Vamos a crear el proyecto PasoPorValor. Los pasos básicos ya
los conocemos:

Modificamos la clase PasoPorValor:
Archivo PasoPorValor.java:
package pasoporvalor;
public class PasoPorValor {

int x = 10;
imprimir(x);//Imprime 10
cambiarValor(x);
imprimir(x);//Imprime 10
}
public static void cambiarValor(int i){

i=200;
}
public static void imprimir(int arg){

System.out.println("Valor recibido:" + arg);
}
}

( )

• Con este ejercicio hemos puesto en práctica el tema de paso
de parámetros por valor.
• En la siguiente lección veremos el tema de paso de

parámetros por referencia.


Crear el ejercicio PasoPorReferencia. Al finalizar deberemos

Vamos a crear el proyecto PasoPorReferencia. Los pasos
básicos ya los conocemos:

Modificamos la clase PasoPorReferencia:
Archivo PasoPorReferencia.java:
package pasoporreferencia;
public class PasoPorReferencia {

Persona p = new Persona();
p.cambiarNombre("Juan");
imprimirNombre(p);//Imprime Juan
modificarPersona(p);
imprimirNombre(p);//Imprime Carlos
}
public static void modificarPersona(Persona arg){

arg.cambiarNombre("Carlos");
}
public static void imprimirNombre(Persona p ){

System.out.println("Valor recibido :" + p.obtenerNombre());
}
}
Creamos la clase Persona:

Modificamos el código de la clase Persona:
package pasoporreferencia;

String nombre;
public void cambiarNombre(String nuevoNombre){

this.nombre = nuevoNombre;
}
public String obtenerNombre(){

return nombre;
}
}

( )

• Con este ejercicio hemos puesto en práctica el tema de paso de
parámetros por referencia.
• Existen mucha polémica, ya que al final de cuentas, sólo existe el paso

por valor en Java, sin embargo aprendimos que si ese valor es la
referencia de un objeto, entonces podemos modificar el objeto
directamente incluso fuera del método donde fue creado el objeto, y por
eso se le llama paso por referencia, ya que es la referencia del objeto
creado.
• Aunque en este código utilizamos la palabra reservada return, la

explicaremos en el siguiente tema a detalle.


lección.
Vamos a estudiar el tema de métodos en Java y la palabra return en Java.
Cuando utilizamos métodos en Java, existen 3 maneras de salir o terminar el

método que se está ejecutando.
La primera opción es utilizar la palabra return, y una vez que se ejecuta esta
instrucción, se regresa el control al método que hizo la llamada previa. La palabra
return puede no regresar ningún valor, es decir, solo colocar la palabra return,
aunque esto no es necesario ya que Java si no se indica otra cosa ejecutará el final
del método y regresará el control al método que hizo la llamada. La otra opción y es
como normalmente se utiliza la palabra return, es agregando un valor, el cual
corresponde con el tipo definido en la firma del método en cuestión.
Posteriormente veremos ejemplos del uso de la palabra return a más detalle.
La segunda opción es cuando llegamos al final de un método, no hay necesidad de

colocar la palabra return de manera obligatoria, sino que una vez que se llega al
final del método se hace return de manera implícita y con ello se obtiene el mismo
resultado que si colocáramos la palabra return sin argumentos.
La tercera forma de salir de un método es si ocurre un error, esto provoca que el

método termine de manera anormal, y ya sea que se procese esta excepción o no,
esto provocará que la ejecución del método concluya. El manejo de excepciones en
Java es un tema que se tratará en otro curso a detalle.
A continuación veremos algunos ejemplos del uso de la palabra return.

Como podemos observar en el código, estamos creando un método llamado sumar, que recibe dos argumentos. La
palabra static la enseñaremos posteriormente, en este caso solo deben agregarla para que el código pueda funcionar
correctamente, y posteriormente la explicaremos a detalle.
Continuando con la definición del método sumar, la firma de este método es: public static int sumar(int, int)
Lo que nos interesa aquí es identificar cual es el tipo de regreso que está indicando este método, el cual es tipo int.
En Java únicamente podemos retornar un valor simple, sin embargo este valor puede ser un tipo primitivo o tipo
object. Y como parte de los tipos object puede ser un arreglo, una lista o una colección de elementos, de esta manera
Java aunque puede regresar sólo un tipo, este tipo puede ser una colección y con ello regresar la referencia a un objeto
de tipo Collection. El tema de arreglos lo estudiaremos más adelante, y el tema de colecciones en otro curso.
Una vez que hemos definido el método sumar, podemos observar que cuando recibe los valores a y b, utilizamos la
palabra return para regresar el resultado de la suma de a mas b.
Podemos utilizar paréntesis o no, esto es opcional, pero lo que debemos saber es que lo que se regresa es el resultado
de la expresión a + b, no los valores por separado, ya que como comentamos Java únicamente regresa un valor simple,
y este método en particular está indicando que lo que regresará es un valor de tipo int, el cual es un tipo primitivo.
Una vez que se termina de ejecutar este método, se regresa el control a el método que hizo la llamada inicial, el cual es
el método main, y se asigna el valor de la suma a la variable resultado.
Esta variable resultado debe ser del mismo tipo que regresa el método sumar, por ello la variable resultado es de tipo
int.
Más adelante realizaremos un ejercicio utilizando la palabra return con tipos primitivos.
Como hemos comentado la palabra return sólo puede regresar un tipo simple, sin embargo puede
ser de tipo primitivo o de tipo Object (cualquiera tipo que este sea). En Java todas las clases
heredan de la clase Object, por lo que esto permite que podamos regresar cualquier tipo Java ya
sea de las librerías ya creadas o alguna tipo (clase) creado por nosotros.
En este ejemplo estamos creando una clase dentro de otra, para poder ejemplificar cómo retornar
un tipo Object. En Java podemos declarar varias clases dentro de una archivo, pero solamente una
de ellas puede ser publica, y la clase publica corresponde con el nombre del archivo de la clase. Por
ello la clase Suma no tiene el modificador public a diferencia de la clase PalabraReturnClases.
En la clase PalabraReturnClases definimos el método main, y un método llamado crearObjetoSuma,

este método realmente no es necesario, lo hemos creado sólo con el fin de demostrar cómo
podemos regresar un tipo objeto desde un método, el cual puede ser directamente en la línea de
código donde se encuentra la palabra return, o podemos crear una variable de tipo Suma, y hacer el
return respectivo de la variable de tipo suma creada previamente.
En otros cursos veremos que cuando decimos que el método debe retornar el mismo tipo definido
en la firma del método, realmente es un valor del mismo tipo o un valor compatible con este tipo,
ya que el tema de herencia en Java, así como el manejo de interfaces, permite declarar una
jerarquía de Clases, la cual genera tipos compatibles entre la jerarquía de Clases, por lo que
veremos a detalle este tema en el siguiente curso. Sin embargo es importante saber que la firma
del método define un tipo y la palabra return debe regresar un valor del mismo tipo o un valor
compatible según la jerarquía de clases a la cual pertenezca dicho tipo.
Finalmente podemos observar que la palabra return puede existir varias veces en un
mismo método, ya que podemos tener código que se ejecute de manera condicional.
De igual manera el código mostrado es sólo para ejemplificar el uso de la palabra

return en caso de que los operando a y b sean cero, en cuyo caso podemos asegurar
que el resultado es 0, y por lo tanto podemos hacer el return del valor 0 en lugar de
realizar la operación respectiva. Sabemos que este código puede implementarse de
otras maneras, sin embargo es para ejemplificar el uso de la palabra return utilizando
una condición con ayuda del bloque condicional if.
Si alguno de los operandos es distinto de cero entonces realizamos la operación

respectiva y regresamos el valor al método main, muy similar al ejercicio creado
anteriormente.

Datos de Contacto:

Crear el ejercicio ReturnTipoPrimitivo. Al finalizar deberemos

Vamos a crear el proyecto PalabraReturn. Los pasos básicos ya
los conocemos:

Modificamos la clase PalabraReturn:
Archivo PalabraReturn:
package palabrareturn;
public class PalabraReturn {

int resultado = sumar(3,6);
public static int sumar(int a, int b){

return a + b;
}
}

( )

package palabrareturn;
public class PalabraReturn {

int resultado = sumar(3,2);
}
public static int sumar(int a, int b){

if(a== 0 && b == 0){
System.out.println("Puede proporcionar valores distintos a cero");
return 0;
}
return a + b;
}
}
( )

• Probar con distintos valores y verificar el resultado, así como

entender a detalle las opciones que se ejecutan según el
código condicionado y ver que palabra return es la que se
ejecuta.

• Con este ejercicio hemos puesto en práctica el uso de la palabra return
utilizando los tipos primitivos.
• Además vimos cómo utilizar esta palabra agregando código

condicionado, en este caso utilizando un bloque if, sin embargo puede ser
cualquier código condicionado.
• En el siguiente ejercicio veremos un ejercicio para utilizar la palabra

return con tipos Object.


Crear el ejercicio ReturnTipoObject. Al finalizar deberemos

Vamos a crear el proyecto PalabraReturnClases. Los pasos
básicos ya los conocemos:

package palabrareturnclases; class Suma {
int a;
public class PalabraReturnClases { int b;
public static void main(String args[]) { Suma(int a, int b) {

Suma s = creaObjetoSuma(); this.a = a;
int resultado = s.a + s.b; this.b = b;
System.out.println("Resultado:" + resultado); }
} }
public static Suma creaObjetoSuma() {

Suma s = new Suma(3, 4);
return s;
}
}

( )


• Con este ejercicio hemos puesto en práctica el uso de la palabra return
utilizando los tipos Object.
• En este ejemplo aunque sencillo, más adelante utilizaremos este mismo

concepto para hacer return de cualquier clase Java, ya sea definida por
nosotros o por alguna otra librería de Java.
• Con esto concluimos el manejo de la palabra return.


Vamos a estudiar el tema de la palabra this en Java.
Hemos visto que la palabra this nos permite acceder al objeto que se está ejecutando
actualmente, sin embargo vamos a dedicar algunos minutos más a este tema para comentar
algunos detalles más.
La palabra this es un operador y básicamente nos permite acceder al objeto que se está
ejecutando en cualquier método Java, sin embargo esto en un principio puede ser algo confuso.
Tenemos dos tiempos en Java según hemos visto, el tiempo de compilación, que es cuando
estamos creando nuestro código, y el tiempo de ejecución que es cuando nuestro programa está
en funcionamiento.
Al momento de crear nuestro código debemos tener presente que no se está ejecutando ningún
código, pero que en un futuro es precisamente lo que sucederá, sobre todo cuando estamos
creando nuestras clases. Por ello, el operador this se tiene que pensar en términos de ejecución
de nuestro código, es decir, cuando se crea un objeto de la clase que estamos codificando.
El operador this es único para cada objeto, y siempre corresponderá al código del objeto que se
esté ejecutando.
Otra cosa importante de mencionar del operador this es que esta palabra únicamente se puede
utilizar dentro de un objeto creado a partir de la clase Java, más adelante veremos lo que significa
el contexto estático, pero podemos adelantar que la palabra this no se puede utilizar en un
contexto estático, ya que en el contexto estático aún no se han creado los objetos, y por lo tanto
la palabra this no tiene utilidad si no se ha creado el objeto al cual debe apuntar.
Uso de los usos más comunes de la palabra this, como ya hemos comentado, es para evitar la ambigüedad entre los
atributos de las clases (miembros de clase) y las variables locales o argumentos de un método.
En el ejemplo podemos observar cómo estamos declarando una clase llamada Persona, la cual tiene un constructor
que recibe un atributo llamado nombre, el cual es idéntico al nombre del atributo de la clase. Para hacer la diferencia
entre ambos nombres, podemos utilizar la palabra this la cual hace referencia al atributo de la clase, de esta manera
podemos nombrar de manera idéntica los argumentos de un método y diferenciar los atributos de la clase por medio
del operador this.
En la figura podemos observar como tanto la variable p como el operador this apuntan al mismo objeto al momento
de llamarse el constructor de la clase. Una vez que termina de ejecutarse el constructor de la clase el operador this
apunta a otro objeto, y si de nueva cuenta se vuele a ejecutar algún método de la clase Persona, el operador this
apuntará al objeto creado, es decir que el operador this siempre apuntará al objeto que se está ejecutando
actualmente.
En este ejemplo podemos observar a más detalle el uso de la palabra this. Estamos creando varias clases y varios objetos
para que podamos observar cómo la palabra this va cambiando según el objeto actual que se está ejecutando.
En la línea 3 creamos un objeto de tipo Persona. Hasta este punto el apuntador this no ha sido creado ni apunta a ningún
objeto. Es sólo hasta que se ejecuta la línea 3 que sea crea el objeto de tipo persona y entonces se crea el apuntador this y
apunta al objeto Persona recién creado.
Sabemos que el paso inmediato en la creación de un objeto en Java es llamar al constructor de la clase, por ello como
siguiente paso se ejecuta la línea 10, en la cual recibimos en la variable local de tipo nombre el valor de Juan, pero para
poder diferencia entre el argumento y el atributo de la clase utilizamos por primera vez la palabra this, de esta manera
hacemos referencia al atributo de la clase.
Posteriormente creamos un nuevo objeto de la clase Imprimir, pero no es hasta que se ejecuta el método imprimir que el
apuntador this cambiará de apuntar al objeto Persona al objeto Imprimir. Por ello en la línea 15 pasamos como parámetro
el objeto Persona actual utilizando la palabra this, y cuando se ejecuta la línea 21 ocurren dos cosas importantes, por un
lado el operador this deja de apuntar al objeto persona y el argumento que recibe el método imprimir es objeto Persona
puesto que this en la línea 15 aún apuntaba al objeto persona.
Todas las clases en Java heredan de la clase Object, y aunque lo veremos en otro tema, la clase Object nos sirve como una
clase comodín para poder recibir cualquier tipo Java como argumento, en este caso la variable Object creada almacena la
referencia de la clase Persona creada anteriormente, y cuya referencia fue enviada en la línea 15 por medio del apuntador
this.
Por ello en la línea 22 se imprime un objeto de tipo Persona, y en la línea 23 se imprime un objeto de tipo Imprimir, ya que
recordemos que this ahora está apuntando al objeto que se está ejecutando actualmente, el cual es de tipo Imprimir.
Hay más cosas que podríamos hacer para mejorar este código, sin embargo necesitamos de más lecciones para poder
mejorar este código, por esta razón vamos a dejar lo más simple posible este código, con el objetivo de entender cómo va
cambiando el apuntador this según la ejecución de nuestro código.

Datos de Contacto:

this

Poner en práctica el uso de la palabra this en Java. Al finalizar

Vamos a crear el proyecto:

Archivo PalabraThis.java:
package palabrathis;
public class PalabraThis {

Persona p = new Persona("Juan");
}
}
class Persona {
String nombre;//atributo de la clase
Persona(String nombre) {
this.nombre = nombre; //this es el objeto Persona (actual)
//Imprimimos el objeto persona

Imprimir i = new Imprimir();
i.imprimir(this); //this es el objeto Persona (actual)
}
}
class Imprimir {
public void imprimir(Object o) {

System.out.println("Imprimir parametro: " + o);//el parametro es el objeto persona
System.out.println("Imprimir objeto actual (this): " + this); //this es el objeto imprimir (actual)
}
}

( )

• Es muy importante entender claramente el uso de la palabra

this, ya que esto será la base para comprender temas más
avanzados de Java.

Con este ejercicio hemos puesto en práctica el uso de la
palabra this, no solamente en su contexto más simple, sino
también en contextos más complejos que nos ayuden a
entender realmente cómo funciona este operador/apuntador
en Java.
Para más información del uso de la palabra this:
https://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html


Vamos a estudiar el tema de la palabra null en Java.
La palabra null en Java la utilizamos con el objetivo de indicar que aún no se le ha asignado ninguna referencia de ningún objeto a una variable de
tipo Object.
No es posible asignar el valor null a una variable de tipo primitivo.
Como podemos observar en la figura, en primer lugar creamos la variable p1 de tipo Persona, la cual se crea en la memoria heap y se le asigna la
ubicación de memoria 0x333.
Posteriormente creamos la variable p2 y el asignamos la referencia almacenada por la variable p1, es decir, que ahora tanto la variable p1 como la
variable p2 apuntan al mismo objeto y ambas variables pueden acceder a él.
Finalmente la variable p1 decidimos que ya no vamos a utilizarla, y para ello asignamos el valor de null, esto significa que pierde la referencia del
objeto creado y por lo tanto solamente la variable p2 podrá ahora acceder al objeto Persona asignado en la ubicación de memoria 0x333.
¿Ahora, qué sucede si hacemos p2 = null ?
Esto significaría que el objeto Persona ya no lo apunta ninguna variable, y por lo tanto queda inaccesible. Desde el punto de vista del recolector de
basura de Java sería un objeto candidato para ser eliminado de la memoria, ya que ninguna variable puede accederlo y por lo tanto es inservible,
ya sólo queda que sea eliminado de la memoria Heap por medio del proceso de recolector de basura llamando al método System.gc(), es decir,
garbage collector o recolector de basura.
Cabe aclarar que el recolector de basura no podemos obligarlo a que inicie su proceso de limpieza de objetos, sólo podemos mandar a llamar al
método y esperar a que la misma máquina virtual de Java decida el momento en que es más conveniente iniciar este proceso, ya que es un
proceso que utiliza muchos recursos. Sin embargo, si ya no vamos a utilizar un objeto, es conveniente y buena práctica que asignemos el valor de
null a la variable que estaba apuntando al objeto creado previamente, con esto una vez que inicie el proceso de recolección de basura el objeto
creado será candidato a ser eliminado.
Finalmente, podemos darnos cuenta que las variables creadas en la memoria Stack son temporales y de menor duración, y una vez concluido el
método y/o programa en el que fueron creadas dichas variables, éstas se destruyen. Sin embargo las variables creadas en la memoria Heap, que
son objetos Java, tienden a durar más tiempo en la memoria, y se destruyen hasta que se concluye el proceso de la máquina virtual de Java
completo.
Por ello es que es buena práctica que si ya no vamos a utilizar un objeto eliminemos cualquier referencia de cualquier variable que apunte a él
asignando el valor de null a dicha variable.
Podemos observar el código de la lámina, en la cual estamos creando un objeto de tipo Persona, y
la referencia la asignamos inicialmente a la variable p1.
En la línea 5 mandamos a imprimir el nombre del objeto Persona cuya referencia está almacenada
en la variable p1. Y podemos observar que el valor es Juan.
Posteriormente en la línea 7creamos la variable p2, esta variable le asignamos el valor de p1, es
decir, ahora p2 también apunta al mismo objeto creado en la línea 4. Esto se comprueba en la
línea 8 donde la variable p2 imprime el mismo nombre de la persona asignado en p1.
Posteriormente utilizamos la palabra null para indicar que la variable p1 NO apunta a ningún
objeto, y de hecho si quisiéramos ejecutar el método de p1.obtenerNombre() nos arrojaría un
error ya que esta variable ya no puede acceder ni a los métodos ni atributos del objeto Persona. El
tema de manejo de excepciones lo estudiaremos a detalle en cursos posteriores, sin embargo es
importante entender el uso de null y la razón por la cual nos marca este error conocido como
NullPointerExcepcion, el cual será uno de los más comunes cuando trabajamos con Java, y
básicamente significa que estamos tratando de acceder a un método o atributo de una clase en la
cual la variable aún no se le ha asignado una referencia de un objeto válida y cuyo valor es null.
Finalmente en la línea 14 comprobamos que la variable p2 continua accediendo sin problemas al

objeto Persona y puede seguir imprimiendo el nombre asignado a este objeto.

Datos de Contacto:

null

Poner en práctica el uso de la palabra null en Java. Al finalizar


Archivo PalabraNull.java:
package palabranull;
public class PalabraNull {

Persona p1 = new Persona("Juan");
System.out.println("Nombre p1:" + p1.obtenerNombre());
Persona p2 = p1; //p2 apunta al mismo objeto que p1

//Hacemos que p1 ya no apunte al objeto p1

p1 = null;
//Comprobamos que p2 sigue accediendo al objeto

//La siguiente linea marca error de tipo NullPointerException

//System.out.println("Nombre p1:" + p1.obtenerNombre());
//Solo en caso de que no sea nulo podemos utilizar este método en esta variable
if(p1 != null){
}
}
}
class Persona {
String nombre; //valor por default es null
public Persona(String nombre) {

this.nombre = nombre;
}
public String obtenerNombre() {

return this.nombre; //Uso opcional de this
}

• Aunque más adelante estudiaremos otros temas como son el

manejo de excepciones, es importante entender cuando es
posible y cuando no utilizar el valor null y qué significa en
cada caso.

Con este ejercicio hemos puesto en práctica el uso de la
palabra null.
Hemos visto como al momento de crear variables que apuntan

a objetos (referencias) es posible indicar que no apuntan a
ningún objeto por medio de la palabra null, y de hecho todos los
atributos de nuestras clases su valor por default es null, por ello
es muy importante entender a qué nos referimos cuando
encontramos el valor null en una variable.


Vamos a estudiar el tema de Encapsulamiento en Java.
Una de las características más importantes de la programación

orientada a objetos es el encapsulamiento.
Esta característica nos permite aislar los datos de nuestros objetos del
acceso de otros objetos externos, y de esta manera restringir el acceso
directo a los atributos o métodos que no deseemos permitir, ya que el
estado de un objeto está generalmente oculto. Podemos entender por
estado de un objeto como los valores actuales de cada uno de los
atributos del objeto, y cualquier cambio en estos valores cambia el
estado interno del objeto.
Al ser uno de los principios más importantes, el encapsulamiento se

logra aplicar a través de los llamados modificadores de acceso. Existen
cuatro modificadores de acceso en Java, los cuales son: private,
package o default, protected y public.
En esta lección estudiaremos sólo los modificadores private y public,

debido a que para el nivel de este curso es suficiente para aplicar el
concepto de encapsulamiento, y en cursos posteriores veremos a
detalle cómo implementar cada uno de estos modificadores de acceso.
Como hemos comentado, comenzaremos con el estudio de los

modificadores: private y public.
Estos modificadores aplican en varias partes de una clase, sin

embargo en esta lección estudiaremos cómo aplican en dos lugares,
en los atributos de una clase, así como en los métodos de una clase.
El modificador private al agregarlo a un atributo o método de una clase

básicamente lo que estamos indicando es que sólo será posible
acceder al atributo o método marcado desde la misma clase y no
desde alguna otra, por ello el nombre de privado.
En cambio el modificador public lo que indica es que es posible

acceder a este a este atributo o método desde cualquier otra clase, por
ello el nombre de publico.
A continuación veremos un ejemplo de cómo aplicar estos

modificadores de acceso a un atributo o método de una clase Java con
el objetivo de aplicar el concepto de encapsulamiento.
Podemos observar en el código mostrado el uso de private y public. Veamos algunos

cambios en la clase Persona.
En la línea 15 el atributo nombre se le ha agregado el modificador de acceso private, de

tal manera que cuando creemos un objeto de tipo Persona (línea 4), no podremos
acceder directamente a modificar el valor del atributo nombre, ya que nos marcará un
error de compilación (línea 7).
Si queremos leer el valor de este atributo, creamos un método para ello, y agregamos el
modificador de acceso public con el objetivo de que cualquier otra clase pueda acceder a
este valor. Por lo tanto, creamos el método obtenerNombre (línea 21) y agregamos el
modificador de acceso public, para posteriormente en la clase de prueba acceder a este
método por medio de la variable de tipo Persona llamada p1 (linea 9).
De esta manera lo que estamos haciendo es modificar nuestra clase Persona para que
ahora el atributo no sea accesible ni para lectura ni para escritura de manera directa, y
tengamos la necesidad de accederlo por medio de métodos públicos que creemos para
cada atributo de nuestra clase.
Sin embargo, esta es una manera informal de aplicar el encapsulamiento en Java, veamos
cómo aplicarlo de manera más formal en la siguiente lámina.
En la lámina podemos observar un código más formal para el concepto de encapsulamiento, es

decir, hemos convertido nuestros atributos a privados (línea 15), y por cada atributo hemos
agregado dos métodos, uno para acceder al atributo (getNombre - línea 17), y otro para modificar
el atributo (setNombre - línea 21).
Estos métodos reciben un nombre especial según la función que realizan. Los métodos de tipo
mutator modifican el valor del atributo de una clase y generalmente se utiliza el prefijo set y
posteriormente el nombre del atributo de la clase respetando la notación de
minúsculas/mayúsculas.
Los métodos de tipo accessors permiten recuperar el valor del atributo de una clase y se utiliza el
prefijo is en caso de ser de tipo boolean y get para los demás tipos de datos, posteriormente
lleva el nombre del atributo de igual manera respetando la notación de mayúsculas/minúsculas
en Java.
En el código mostrado en el ejemplo podemos observar el uso de estos mutators y accessors.

Como hemos comentado el objetivo es generar una interface que permita encapsular el estado
del objeto Java y que no sea posible acceder directamente al estado del objeto y modificarlo, sino
que sea a través de los mutators y si queremos conocer el estado del objeto sea a través de los
accessors.
En este ejemplo debemos entender que la clase de prueba es la clase publica llamada
PruebaEncapsulamiento, y que la clase en la que se aplicó el concepto de encapsulamiento fue
sobre la clase Persona. Es decir que son clases distintas, y por ello el código que tenemos en el
método main (líneas 4 a 9) es código que esta fuera de la clase Persona y allí radica el concepto
de encapsulamiento, es decir, evitar que clases externas a la clase persona puedan acceder a los
atributos de la clase Persona directamente, sin importar que sea una clase declarada en un
mismo archivo, son clases distintas.
A continuación veremos otra forma de conceptualizar el encapsulamiento.
Como podemos observar en la lámina, la idea de encapsulamiento de la programación orientada a objetos es evitar el acceso y manipulación
directa de otras clases a los datos de un objeto, por dato nos referimos a cualquier atributo de la clase en cuestión, esto es, el estado del objeto.
Para evitar el acceso directo de otras clases a los datos de la clase que deseamos encapsular lo primero que debemos hacer, según hemos
comentado, es agregar el modificador de acceso private a nuestros atributos de clase, de esta manera únicamente los métodos de la misma clase
son los que podrán acceder (leer/get) y manipular (modificar/set) los datos de la clase que estamos creando.
Por otro lado, ¿Cómo podrán acceder una clase externa a los datos de nuestros objetos encapsulados? La respuesta es creando métodos públicos
por cada atributo privado, los cuales puedan tanto modificar como recuperar el valor de nuestros datos o atributos de clase. A esto se le conoce
como la interface del objeto, debido a que es a través de estos métodos que nos estaremos comunicando con el objeto creado y así poder leer el
estado de cada dato y/o modificar también sus datos. Normalmente se crean dos métodos públicos por cada atributo privado, un método set y
otro get.
Los métodos que modifican los datos se conocen como mutators y llevan el prefijo set (colocar) seguido del nombre de la variable en notación de
mayúsculas/minúsculas. Por otro lado, los métodos que leen la información de los datos se conocen como accessors y llevan el prefijo de get
(obtener) seguido del nombre de la variable, excepto en los casos en que la variable sea de tipo boolean, entonces el prefijo en lugar de get será
is (es).
Ahora, ¿Por qué evitar la modificación directa del estado de un objeto en Java, y en general en la programación orientada a objetos? Lo que
buscamos es que tengamos un control sobre la información y estado de nuestros objetos, de tal manera que si queremos por ejemplo modificar
el dato1, podamos aplicar una validación sobre la información que queremos colocar en el dato1, y este sea un valor adecuado, como puede ser
la restricción de recibir sólo números, entonces, antes de hacer la actualización del valor del dato1 podamos verificar que efectivamente el valor
que se va a colocar sea un valor numérico, esto sólo por poner un ejemplo sencillo, pero la idea es que otros objetos no puedan directamente
modificar el estado de nuestros objetos si no lo deseamos, y de esta manera el concepto de encapsulamiento en Java nos permite lograr esto,
ocultando cualquier validación pero aplicándola en todo momento, respetando en todo momento las reglas que apliquen al estado del objeto.
En la lámina podemos observar que los atributos tienen un símbolo de – (menos), y que los métodos tienen un símbolo de + (mas), esto es parte
de la notación de este diagrama de dona o de objetos, y lo que nos indica es que el signo de – es el modificador de acceso private, y el signo de +
es el modificador de acceso public, de esta manera podemos observar gráficamente los elementos privados y públicos en nuestro objeto Java.
Esto es sólo un resumen de lo que hemos visto anteriormente, pero es otra forma en que podemos entender el concepto de encapsulamiento.
Pondremos en práctica este concepto en el siguiente ejercicio.

Datos de Contacto:
Por el experto: Ing. Ubaldo Acosta

Poner en práctica el concepto de Encapsulamiento en Java. Al
finalizar deberemos observar lo siguiente:

Vamos a crear una clase llamada Persona, la cual aplicaremos el
concepto de encapsulamiento como sigue:
Atributos
privados
Métodos
públicos


Vamos a crear la clase Persona:

( )

package encapsulamiento;
public boolean isBorrado() {
public class Persona { return borrado;
//Constructor Vacio }
public Persona() {
} public void setBorrado(boolean borrado) {
//Constructor con 3 argumentos this.borrado = borrado;
public Persona(String nombre, String apellido, boolean borrado) { }
this.apellido = apellido; //Método que imprime el estado del objeto
this.borrado = borrado; @Override
} public String toString() {
return "Persona{" + "nombre=" + nombre + ", apellido=" +
//Atributos privados apellido + ", borrado=" + borrado + '}';
private String nombre; }
private String apellido; }
private boolean borrado;
//Métodos publicos para acceder y/o modificar los atributos

public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {

}
public String getApellido() {

return apellido;
}
public void setApellido(String apellido) {

this.apellido = apellido; www.gl obal mentoring.com .mx
}
Archivo Encapsulamiento.java:
package encapsulamiento;
public class Encapsulamiento {

//Creamos el objeto
Persona p1 = new Persona("Juan","Perez",false);
//Accedemos al atributo nombre
System.out.println("Nombre de p1: " + p1.getNombre());
//Creamos el objeto
Persona p2 = new Persona("Karla","Gonzalez",false);
//Imprimimos el estado completo del objeto
System.out.println("Estado objeto p2:" + p2);
//Marcamos como elminada a la persona

p2.setBorrado(true);
//Creamos un tercer objeto vacio

}
}

• Modificar más atributos e imprimir el estado de cada objeto

y también imprimir atributos de manera individual con el
objetivo de entender a detalle el manejo del concepto de
encapsulamiento.

Con este ejercicio hemos puesto en práctica el concepto de Encapsulamiento. Hemos visto
cómo utilizar los modificadores de acceso private y public para lograr este objetivo.
Es importante entender a detalle este concepto, ya que es la base para muchas de las clases
que esteremos desarrollando a lo largo de este y los siguientes cursos.
Nota: El método toString() nos permite convertir un objeto Java en una cadena, por ello lo
utilizamos para poder mandar a imprimir el estado del objeto en Java. Para entender a detalle
la explicación de este método necesitamos haber estudiado los temas de herencia y
polimorfismo, sin embargo aplicarlo, como hemos visto, es realmente simple, solo debemos
agregarlo a nuestra clase y concatenar los atributos para mostrar el estado de nuestro objeto,
es decir, los valores de cada atributo, eso es todo lo que debemos hacer para implementarlo, sin
embargo para entender su funcionamiento a detalle lo estudiaremos posteriormente.


lección..
Vamos a estudiar el tema del contexto estático.
Comencemos con esta lección diferenciando el contexto estático del contexto dinámico.
Para comenzar a crear objetos de una clase, primero se debe cargar la clase en memoria por medio de lo que se
conoce como ClassLoader (cargador de clases). Aquí entra por primera vez el concepto de contexto estático, y podrá
ser utilizado hasta que la clase se elimine de la memoria, que normalmente ocurre cuando se detiene el proceso de la
máquina virtual de Java, es decir, que la clase está cargada durante todo el proceso de la ejecución de nuestra
aplicación.
Una vez que la clase ya está cargada en memoria, es posible empezar a crear objetos de dicha clase. A esto se le
conoce como el contexto dinámico, ya que en este momento ya es posible crear objetos y empezar a interactuar
entre los mismos.
En resumen, el contexto estático se carga primero y por lo tanto las clases que se vayan a utilizar, y posteriormente
se crea el contexto dinámico y por lo tanto ya se pueden crear los objetos de las clases que se hayan cargado en
memoria. Como podemos observar en la lámina, el contexto estático tiene una mayor duración que el contexto
dinámico, y de hecho el contexto estático incluye el contexto dinámico, pero no al revés.
El operador this sólo tiene uso cuando se ha creado un objeto de una clase, por lo tanto no es posible utilizarlo en el
contexto estatico.
El contexto estático lo podemos trabajar en el código Java por medio de la palabra static, la cual explicaremos a
continuación.
Podemos utilizar la palabra static para interactuar con el contexto estático. Por ejemplo, si
definimos un atributo o un método como estático, lo que estamos indicamos es que el atributo o
método pertenecen a la clase y no al objeto.
Por ejemplo, si creamos un atributo sin usar la palabra static, que es como normalmente los
definimos, cada que creamos un objeto se creará también una variable asociada al objeto que se
crea, pero si definimos el atributo como estático, estamos indicando que el atributo solo se crea
una vez, sin importar cuantos objetos se creen, sólo habrá una variable la cual se asocia a la clase
y no al objeto. Y si un objeto accede al valor de la variable estática leerá el mismo valor que los
demás objetos, y si un objeto modifica el valor estático, todos los demás objetos accederán al
mismo valor ya que este valor está almacenado en la clase y no en los objetos de dicha clase.
Utilizando la palabra static es posible interactuar con la clase sin necesidad de haber creado un
objeto de la misma. Por ejemplo, podemos acceder a atributos y/o métodos sin necesidad de
haber instanciado ningún objeto de la clase que deseamos utilizar. Con el uso de la palabra static
ya sea en el atributo o en el método que deseamos acceder podremos usar directamente el
atributo o método sin necesidad de generar un objeto de la clase, solo colocando el nombre de la
clase, el operador punto, y finalmente el nombre del atributo o método estático definido en la
clase. Normalmente los atributos o métodos estáticos si deseamos que sean accedidos desde
otras clases deberán contener el modificador de acceso public para que no tengan ningún
problema en ser accedidos.
Por lo tanto, los atributos o métodos marcados con la palabra static se les conoce como
miembros de clase o métodos de clase, ya que pertenecen a la clase y no a los objetos que se
crean de dicha clase.
Una vez que hemos mencionado el contexto estático y el dinámico, podemos aclarar lo siguiente.
El operador this se asocia con el contexto dinámico, y debido a que el contexto estático carga
primero que el contexto dinámico, el operador this no funciona en el contexto estático.
Es por esta razón que en el método main o cualquier otro método estático, no es posible utilizar
el operador this.
En pocas palabras, un método estático puede acceder a otro método estático, pero no a un
método NO estático, ya que el contexto dinámico aún no se crea.
Pero, un método dinámico (no estático) SI puede acceder a un método estático, ya que este
contexto ya ha sido creado.
Ahora, podemos acceder a un método dinámico desde un método estático siempre y cuando
creemos un nuevo objeto. De esta manera es si podemos acceder a métodos dinámicos, pero
esto se debe a que una vez que creamos un objeto, por ejemplo dentro del método main, lo que
estamos haciendo es creando el contexto dinámico, y por lo tanto ya es posible acceder a los
métodos del objeto a través del mismo. De esta manera es que un objeto puede acceder tanto a
los métodos no estáticos o estáticos. Sin embargo un método estático aunque pueda ser accedido
por medio de un objeto, lo correcto es que utilice el nombre de la clase y no el nombre del
objeto.
En el ejemplo mostrado podemos observar un ejemplo del uso de la palabra static.
Por un lado declaramos una variable de tipo static llamada contadorPersonas. Al declarar esta variable como estática, lo que buscamos es que
cada vez que creamos un objeto de tipo Persona, vamos a incrementar el valor de esta variable. Esto lo podemos lograr utilizando el constructor
de la clase, ya que cada que creamos un objeto de tipo Persona, se mandará llamar el constructor de la clase, y allí podemos incrementar esta
variable con cada llamada realizada al constructor (línea 20).
Una vez que se ha incrementado esta variable estática, este valor aplica para todos los objetos, por lo tanto cada que incrementamos esta variable
puede ser consultada por todos los objetos que creemos y de esta manera es que esta variable no comienza desde cero cada que creamos un
nuevo objeto, sino que se queda en el último valor y se incrementa una vez más, esto debido a que esta variable pertenece a la clase y no a los
objetos.
Una vez que ya tenemos el nuevo valor, podemos entonces asignar el nuevo valor al atributo idPersona ( línea 22), y el valor de idPersona al no ser
estático será único para cada objeto, de allí que podemos estar seguros que el valor será único para cada objeto creado de tipo Persona.
Otra sección importante de este código es la línea 27, en la cual declaramos el método getContadorPersonas( ), con este método el cual es
estático, podemos recuperar el valor de contadorPersonas, para saber cuantos objetos de tipo Persona se han creado.
Ahora, en el método main, el cual es un método estático, vamos a hacer uso de la clase Persona. En primer lugar crearemos un objeto de tipo
Persona, y asignamos el valor de Juan al atributo nombre con ayuda del constructor de la clase.
Desde el momento que estamos utilizando la palabra new, quiere decir que ya estamos trabajando con el contexto dinámico, esto permite
trabajar ya con el contexto dinámico (objetos) y el contexto estático (clases).
Por lo tanto al crear el objeto persona, el constructor de la clase se encarga de asignar el idPersona con un valor único al incrementar la variable
contadorPersonas, la cual al ser estática permite que el conteo de objetos Persona sea correcto.
En este código estamos omitiendo la implementación del método toString para la clase Persona, el cual se debe agregar para observar el estado
del objeto persona impreso en la línea 5.
Finalmente, una vez que hemos terminado de crear objetos de tipo persona, podemos mandar a imprimir el número total de objetos Persona que
se han creado, y aquí es donde podemos observar la notación que hemos platicado, para mandar a llamar un método estático público de una
clase basta con colocar el nombre de la clase, el operador punto y el nombre del método estático, es decir que no debemos utilizar el objeto, de
hecho no es buena práctica y si insistimos en usar una variable de tipo object para mandar a llamar un método estático nos mostrará un warning,
avisándonos que es una mala práctica.
Con esto concluimos el uso del contexto estático.



Crear un programa para poner en práctica concepto de
contexto estático. Al finalizar deberemos observar lo siguiente:

Vamos a crear el proyecto :


package ejemplostatic;
private String nombre;

private int idPersona;
private static int contadorPersonas;
public Persona(String nombre){

//Cada que creamos un objeto persona incrementamos el contador
//para obtener un nuevo idPersona
contadorPersonas++;
//asignamos el nuevo valor al idPersona
idPersona = contadorPersonas;
//Asignamos el nombre recibido
}
public String toString(){

return "Persona[idPersona: " + idPersona + ", nombre: " + nombre + "]";
}
public static int getContadorPersonas(){

return contadorPersonas;
}
Archivo EjemploStatic.java:
package ejemplostatic;
public class EjemploStatic {

Persona p1 = new Persona("Juan");
System.out.println("Persona1: " + p1);
Persona p2 = new Persona("Karla");

System.out.println("Persona2: " + p2);
//Imprimimos el contadorPersonas
System.out.println("No. Personas:" + Persona.getContadorPersonas());
}
}



• Con este ejercicio hemos puesto en práctica el contexto
estático.
• Para más información de este concepto, consultar:
• https://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html


lección.
Vamos a estudiar el tema de la herencia en Java.
En esta lección vamos a estudiar el tema de herencia.
Una de las formas en que entendemos la herencia, son las características

que se mantienen de generación en generación en una familia. Por
ejemplo los abuelos tenían cabello rubio, y un de los hijos hereda esta
característica, a su vez el hijo tiene a su vez un hijo que también hereda
el cabello rubio.
Por otro lado los mismos abuelos pudieron haber tenido una hija con
cabello castaño y lacio, y los nietos pueden heredar también esta misma
característica de tener el cabello castaño y lacio.
En la programación orientada a objetos, el concepto de herencia es

exactamente igual. Definiremos una jerarquía de clases que nos
permitirán heredar características entre clases Padre y clases Hijas.
Veamos a continuación algunas características particulares de Java.
La herencia es uno de los conceptos más importantes en la programación

orientada a objetos (POO), y mencionaremos algunas de las razones más
importantes por la cuales aplicaremos este concepto en el diseño de
nuestras clases.
• La herencia nos permitirá representar características o

comportamiento en común entre clases, permitiendo definir en la clase
Padre los atributos o métodos que sean comunes a las clases hijas, las
cuales heredarán estos atributos o métodos definidos en la clase
Padre.
• Lo anterior permite evitar duplicar el código entre la clase Padre y las
clases Hijas, por lo que cumplimos con la reutilización de código que es
uno de los principales objetivos de la POO.
• Si aplicamos el concepto de Herencia, podemos modelar de una
manera más sencilla sistemas del mundo real. Si ya la definición de
objetos es un gran aporte, diseñar una jerarquía de clases, nos facilitará
aún más el modelado de clases.
Vamos a ver un ejemplo de herencia en Java. Podemos observar una clase llamada Persona, la cual como cualquier persona
tiene muchas características, pero nos vamos a enfocar a unas cuantas. Una persona tiene un nombre, un genero, una edad y
una dirección, vamos a capturar estas características en cada uno de los atributos que corresponden en la clase Java, puede
tener muchos más, pero nos vamos a enfocar en estos para simplificar el ejemplo.
Por otro lado, si estamos tratando de modelar un sistema de ventas, podríamos tener algunas variantes de una persona en
nuestro sistema, por ejemplo la clase de Empleado y Cliente.
A diferencia de una simple Persona, un Empleado tiene sueldo, y su actividad puede definir el tipo de empleado que es.
Vendedor, Gerente, sin embargo no vamos a ir a más detalle en este ejemplo, vamos a dejar el ejemplo de herencia sólo hasta la
relación de Persona – Empleado. Un empleado también tiene un identificador, el cual es único para cada empleado, y la clase
Empleado tiene los métodos para cada atributo.
Por otro lado, podemos tener un cliente que se registra en el sistema de Ventas, este Cliente puede tener como atributos un
identificador generado de manera muy particular para él, también podemos tener una fecha de alta o de registro, y también
podemos indicar si es un cliente especial o VIP, para tales casos, asignamos las variables descritas en la clase Cliente, así como
los métodos respectivos.
En este ejemplo no estamos indicando cómo llegamos al diseño de estas clases, sin embargo el proceso general es identificar los
actores u objetos (entidades que generalmente serán nuestras clases) que interactuarán en nuestro sistema, y a partir de las
necesidades de nuestro sistema podemos ir anotando cuales son las características (atributos) y funcionalidad (métodos) que
debe tener cada entidad registrada.
Una vez que se han encontrando estas entidades con sus atributos y métodos, vemos si existen características o funcionalidad
en común, y allí es precisamente como llegamos a este tipo de diseños. Podemos observar que la clase Persona es la clase Padre
y que las clases Empleado y Cliente extienden de la clase Persona, es decir, que heredan las características de la clase Persona.
Esto permite que no tengamos que repetir el código ya definido en la clase Persona, y una vez que creamos un objeto de tipo
Empleado o Cliente, en automático también tendrá las características de la clase Persona. En la siguiente lámina veremos un
ejemplo más visual de esto.
En esta lámina podemos observar del lado izquierdo la definición de dos clases con herencia. Este es una
forma en que podemos imaginar visualmente lo que ocurre con la definición de clases una vez que
manejamos el concepto de herencia.
Lo que visualizamos es que la clase Persona tiene atributos privados y varios métodos públicos. Los
atributos privados no se heredan, al igual que los métodos privados. Es decir, mientras usemos el
modificador de acceso private no se heredara el atributo o método marcado con este modificador.
Pero el modificador public si se hereda. Más adelante mencionaremos lo que sucede con los modificadores
de tipo package y protected, de momento manejaremos solo estos dos modificadores, private y public
para simplificar la explicación del concepto de herencia.
Como observamos la figura muestra la definición “completa” de la clase Empleado, la cual al heredar de la
clase Persona, hereda las características que no son privadas, es decir, no hereda los atributos ya que se
definieron como private, pero sí hereda los métodos definidos como públicos. Esto permite que cuando
creemos un objeto de tipo empleado, como el descrito del lado derecho de la lámina, podemos observar
que este objeto de tipo Empleado tiene acceso tanto a los métodos heredados de la clase Persona, así
como a los métodos definidos en la misma clase Empleado.
Debemos notar que puede ser puede heredar ya sea atributos o un métodos, lo que lo restringe es el
modificador de acceso, ya sea private o public. Recordemos que son 4 modificadores de acceso en total,
pero por ahora simplicaremos con sólo estos dos.
En resumen, cuando visualicemos una clase que herada de otra, podemos imaginarnos a esta clase como
el conjunto de sus propios atributos y métodos, así como la suma de los atributos o métodos hererables de
la clase o clases Padre, ya que puede recibir herencia de una clase Padre, o una clase “Abuelo”, es decir,
una clase Padre de su propia clase Padre.
Para definir la herencia en Java basta con utilizar la palabra extends en la definición de la clase Java e indicar el nombre de
la clase Padre.
Ej. class Empleado extends Persona
Cabe aclarar que en Java la herencia es simple, esto quiere decir que sólo podemos heredar de una clase a la vez. Puede
haber una jerarquía de clases hacia arriba, por ejemplo Clase Abuelo, Padre e Hija, pero una clase no puede heredar por
decir de una clase Padre y una clase Madre, es decir, de dos clases al mismo tiempo, únicamente por jerarquía de clases.
Esto SI está permitido, definir una Jerarquía de clases (Clase Padre o SuperClase, Clase Hija o SubClase) :
class Persona
class Empleado extends Persona
class Gerente extends Empleado
Esto NO está permitido (NO se puede heredar de dos clases a la vez, en Java la herencia es simple):
class Gerente extends Empleado, Persona
Es importante indicar que TODAS las clases en Java heredan de la clase Object, de manera indirecta o directa. En el caso
de la clase Persona, como no está indicando que hereda de alguna clase, es decir, no usa extends en la definición de su
clase, se entiende que en automático hereda de la clase Object. Pero las clases Empleado o Gerente, debido a que
extienden de otra clases, heredarán los métodos de la clase Object de manera indirecta, pero todas las clases en Java de
una manera u otra heredan las características de la clase Object. Finalmente, la clase Object es la clase core o base de
Java, y pertenece al paquete java.lang. Posteriormente hablaremos del tema de paquetes en Java.
Si aplicamos el concepto de herencia la clase Hija o Subclase puede acceder a los atributos, métodos o
constructores permitidos de la clase padre solo con utilizar la palabra super.
De esta manera podemos aprovechar código heredado y aprovecharlo por ejemplo para iniciar un objeto
de la clase hija. Esto es muy común utilizarlo dentro del constructor para llamar desde el constructor de la
clase hija al constructor de la clase Padre.
El constructor de la clase Hija sólo realizará el trabajo correspondiente a la clase Hija, como puede ser la
asignación de atributos, pero no realizará el trabajo que ya realiza el constructor de la clase Padre si es
posible utilizarlo. Para ello se utiliza la palabra super.
De hecho la palabra this se puede utilizar de manera idéntica pero para llamar a un constructor de la
misma clase, y la palabra super para llamar a los constructores de la clase Padre. Ojo, super no solo
permite llamar constructores de la clase padre, sino cualquier atributo, método o constructor heredable
de la clase Padre.
En el ejemplo podemos observar que utilizamos la palabra super para mandar a llamar el constructor de la
clase Padre desde la clase Hija.
En la lámina podemos observar un ejemplo para el uso del método toString( ). El método toString( ) según hemos comentado, lo
vamos a utilizar para mostrar el estado de un objeto, es decir, los valores de los atributos en cierto momento del tiempo de vida
del objeto.
El método toString es un método heredado de la clase object. La clase Object es la clase Padre de todas las clases Java, ya sea de
manera explícita o implícita, según hemos comentado. Por ejemplo, en el caso de la clase Empleado, la clase Object sería la clase
abuela de la clase Empleado, debido a que se ha definido que de manera explícita la clase Persona como su clase Padre, y
debido a que la clase Padre no ha indicado que extiende de alguna clase, entonces se entiende que su clase padre es la clase
Object. De esta manera la clase Empleado también recibe los métodos y atributos que llegase a heredar de la clase Object.
Para indicar que un método pertenece a una clase padre o de nivel superiores, como la clase Object, entonces debemos agregar
la anotación @Override, esto quiere decir que estamos sobreescribiendo el comportamiento de un método de la clase padre o
clases superiores. Sin embargo este tema de sobreescritura lo estudiaremos en el siguiente curso. Pero para el ejemplo de este
curso sólo diremos que es necesario agregar esta anotación para que indiquemos al compilador Java que sabemos que es un
método definido en una clase superior, en este caso es un método público de la clase Object.
Ahora, este método toString( ) nos sirve según hemos comentado, para convertir el estado de un objeto a una cadena. Pero
para el caso que estamos mostrando, la clase Persona tiene su método toString( ) y lo ideal es que reutilizaramos este código
para completar el método toString de la clase Empleado, ya que si combinamos el método toString de la clase Persona con el de
la clase Empleado, entonces podremos mostrar el estado de todos los atributos de la clase Empleado y de su clase padre
Persona.
¿Cómo hacemos esto? Como observamos en el código, lo que hacemos es utilizar la palabra super, y debido a que toString es un
método público redefinido (sobreescrito) en la clase Persona, entonces podemos acceder a este método de la clase padre por
medio de la palabra super, el operador punto y el nombre del método que deseamos acceder del padre. Esto nos va a regresar
una cadena con el estado del objeto Persona, y con ello solo basta concatenar el valor que aún no hemos colocado de la clase
Empleado, por ello concatenamos el valor de la variable sueldo y ahora si podemos regresar la cadena completa para que ahora
el método toString de la clase Empleado pueda mostrar tanto su propio estado como el estado de cada atributo de su clase
padre que es Persona.
Esto lo pondremos en práctica en el ejercicio siguiente.


Datos de Contacto:

Crear un ejercicio para aplicar el concepto de Herencia en Java.

El siguiente es un diagrama de Clases del ejercicio, creado con
la herramienta http://www.umlet.com/umletino/umletino.html:


package ejemploherencia;
public char getGenero() {
public class Persona { //Definición de la clase Padre return genero;
private String nombre; }
private char genero;
private int edad; public void setGenero(char genero) {
private String direccion; this.genero = genero;
}
//Constructor vacio
public Persona(){} public int getEdad() {
return edad;
//Constructor 1 argumento }
public Persona(String nombre){
this.nombre = nombre; public void setEdad(int edad) {
} this.edad = edad;
}
//Constructor completo
public Persona(String nombre, char genero, int edad, String direccion){ public String getDireccion() {
this.nombre = nombre; return direccion;
this.genero = genero; //M-Masculino, F-Femenino }
this.edad = edad;
this.direccion = direccion; public void setDireccion(String direccion) {
} this.direccion = direccion;
}
return nombre; @Override
} public String toString() {
return "Persona{" + "nombre=" + nombre + ", genero=" + genero + ",
public void setNombre(String nombre) { edad=" + edad + ", direccion=" + direccion + '}';
this.nombre = nombre; }
} }

Archivo Empleado.java:
package ejemploherencia; public double getSueldo() {
return sueldo;
public class Empleado extends Persona { }
private int idEmpleado; public void setSueldo(double sueldo) {

private double sueldo; this.sueldo = sueldo;
private static int contadorEmpleados; }
public Empleado(String nombre, double sueldo) { @Override

super(nombre); //Super debe ser la primera linea public String toString() {
this.idEmpleado = ++contadorEmpleados; //Primero mandamos a llamar el método toString de la clase
this.sueldo = sueldo; Persona
} //para que podamos observar los valores de la clase Padre,
//y despues imprimimos los valores de la clase hija
public int getIdEmpleado() { return super.toString() + " Empleado{" + "idEmpleado=" +
return idEmpleado; idEmpleado + ", sueldo=" + sueldo + '}';
} }

Archivo Cliente.java:
package ejemploherencia; public Date getFechaRegistro() {
return fechaRegistro;
import java.util.Date; }
public class Cliente extends Persona{ public boolean isVip() {

private int idCliente; return vip;
private java.util.Date fechaRegistro; }
private boolean vip;
private static int contadorClientes; public void setVip(boolean vip) {
this.vip = vip;
public Cliente(Date fechaRegistro, boolean vip) { }
this.idCliente = ++contadorClientes;
this.fechaRegistro = fechaRegistro; @Override
this.vip = vip; public String toString() {
} //Primero mandamos a llamar el método toString de la clase
Persona
public int getIdCliente() { //para que podamos observar los valores de la clase Padre,
return idCliente; //y despues imprimimos los valores de la clase hija
} return super.toString() + " Cliente{" + "idCliente=" +
idCliente + ", fechaRegistro=" + fechaRegistro + ", vip=" + vip +
'}';
}
}

Archivo EjemploHerencia.java:
package ejemploherencia;
public class EjemploHerencia {

Empleado e1 = new Empleado("Juan", 25000);
System.out.println("Imprimimos el objeto Empleado1");
System.out.println(e1);
Empleado e2 = new Empleado("Pedro", 15000);

e2.setEdad(28);
e2.setGenero('M');
e2.setDireccion("Bogota, Colombia");
System.out.println("\nImprimimos el objeto Empleado2");
//Al crear un nuevo objeto de java.util.Date nos regresa la fecha actual

Cliente c1 = new Cliente(new java.util.Date(), false);
System.out.println("\nImprimimos el objeto Cliente1");
System.out.println(c1);
//Completamos el objeto persona asociado a este objeto cliente
c1.setNombre("Karla");
c1.setEdad(22);
c1.setGenero('F');
c1.setDireccion("México, DF");
System.out.println("\nVolvemos a imprimir el objeto cliente1");
System.out.println(c1);
}
}
Ejecutamos nuestro proyecto. El resultado es:

• Crear más variables tanto de objetos Persona, Empleado y

Cliente y verificar resultados.

• Con este ejercicio hemos puesto en práctica el concepto de
Herencia y varios puntos más.
• Hemos observado que conforme avanzamos el curso comienza a

ser mayor el código que escribimos y más interesante. Conforme
vayamos avanzando iremos integrando este tema, el cual será de
los más recurrentes al momento de trabajar con Java, ya sea de
manera directa o indirecta, pero el tema de herencia está presente
todo el tiempo.


Vamos a estudiar el tema de Sobrecarga de Constructores en Java.
En esta lección para a tratar el tema de sobrecarga de Constructores.
En primer lugar, la sobrecarga de Constructores tiene que ver con ofrecer distintas opciones para crear un
objeto de una clase en particular, esto lo lograremos creando distintos Constructores con distintos
argumentos, ya sea en número o en tipo de dato. Recordemos que el nombre del constructor es igual al
nombre de la clase, respetando que Java es sensible a mayúsculas y minúsculas. Por lo tanto siempre que
encontremos un método que sea igual al nombre de la clase y que no regrese ningún tipo de dato,
entonces será un Constructor de la clase, pudiendo existir varios en la misma clase.
Podemos decir entonces, que la sobrecarga de un Constructor es ofrecer más opciones para poder
construir un objeto de una clase. En el código mostrado en la lámina podemos observar que en primer
lugar se ha creado el constructor vacío Persona (línea 4), es decir, sin argumentos. Sin embargo muchas
veces queremos ofrecer más opciones de construir un objeto de tipo Persona y que desde el momento de
la creación obligue a proporcionar los datos de nombre y edad.
Por lo tanto, agregamos un constructor sobrecargado, con 2 argumentos (línea 9), por lo que tenemos
Persona( String, int). Lo importante al momento de sobrecargar un Constructor es observar los tipos de los
argumentos, y no sus nombres, por lo que no debe existir otro constructor con los mismos tipos ya
definidos en el mismo orden en que se define. Sin embargo, si agregamos un Constructor llamado Persona
con los argumentos invertidos, es decir, Persona(int, String) entonces éste se considera otra sobrecarga de
los constructores ya definidos. Es decir que el orden y el tipo de los argumentos sí importa.
En resumen, la sobrecarga de Constructores, es definir un Constructor con el mismo nombre de la clase,

pero con distintos argumentos, considerando el tipo y orden de los argumentos. Esto se hace con el
objetivo de brindar varias opciones para la creación de nuestros objetos según la clase que estemos
codificando.
En ocasiones podemos tener llamadas entre constructores de la misma clase. Existen varias
razones para realizar esta tarea, pero supongamos que el constructor vacío hace la tarea de
asignar un valor al atributo idPersona, entonces este código podemos evitar repetirlo en otros
constructores únicamente haciendo una llamada al constructor vacío desde cualquier otro
constructor sobrecargado.
Para hacer este llamada entre constructores es que utilizamos la palabra this y posteriormente
especificamos los argumentos que enviamos según el constructor que deseemos utilizar. En
nuestro ejemplo estamos llamando al constructor vacío (línea 12) con el objetivo de reutilizar el
código que ya realiza el constructor vacío. De hecho podemos observar como una característica
extra que el constructor vacío es privado, es decir que no podemos crear objetos de tipo Persona
sin argumentos, sino que forzosamente debemos utilizar algún constructor sobrecargado con
argumentos, en este caso debemos proporcionar el nombre y la edad de la persona de manera
obligatoria, y de manera interna la funcionalidad de asignar el valor de idPersona lo realiza
internamente la clase Persona por medio del constructor vacío, por ello se manda a llamar el
constructor vacío por medio de this( ), esto quiere decir que se manda a llamar al constructor sin
argumentos. Si tuviéramos un constructor con solo un argumento de tipo String y quisiéramos
mandarlo llamar desde otro constructor, la sintaxis sería: this( “Cadena” ); es decir que
deberíamos proporcionar un argumento de tipo string para llamar este argumento.
La única condición para mandar a llamar a otro constructor desde un constructor sobrecargado es
que el uso de this sea la primera línea del constructor, por ello la línea 12 lo primero que se usa
en el constructor es this( );
También es posible utilizar esta característica con clases Hijas, es decir, cuando estamos
manejando herencia, veamos cómo se realiza esta tarea.
Partiendo de la clase Persona que tenemos en la lámina anterior, definiremos la clase Empleado, la cual extiende de la clase
Persona. Por lo tanto hereda todas las características que son heredables, es decir, que no son de tipo private.
Esto quiere decir que la clase Empleado tiene acceso al constructor público Persona de dos argumentos (String e int), y por lo
tanto podemos apoyarnos de el para inicializar los atributos de la clase Persona. De hecho por la forma en que está construida la
clase Persona, es la única forma de inicializar los atributos de dicha clase.
Por ejemplo el atributo idPersona de la clase Persona, no existe forma de accederlo directamente, ni siquiera a través de algún
método o un constructor. La única manera de accederlo e inicializarlo es mandando a llamar el constructor vacío, sin embargo
este constructor vacío de la clase Persona es privado, por lo tanto no podemos usarlo desde la clase Empleado.
La única forma que tenemos de inicializar el objeto Persona es a través de la llamada al constructor público Persona(String
nombre, int edad). Ahora, ¿la pregunta es cómo podemos acceder a este constructor?
La respuesta es utilizando la palabra super. Esta palabra nos permite acceder a los constructores, métodos o atributos de la clase
padre siempre y cuando sean accesibles para nuestra clase. Cuando veamos a detalle el tema de modificadores de acceso veremos
que existen otros modificadores además de public que nos permitirán acceder a Constructores, métodos o atributos de la clase
padre.
Sin embargo para el ejemplo que estamos mostrando, la palabra super la estamos usando para inicializar los atributos de la clase
Persona, de la cual extiende Empleado, si no lo hiciéramos de esta forma, estaríamos dejando sin asignar los valores respectivos a
los atributos de la clase Persona, ya que todos sus atributos son privados, y se podrían asignar valores si existieran métodos de
tipo mutator (set) para los atributos respectivos, pero si no existe este método mutator entonces se quedarían sin inicializar.
Así que este es un ejemplo de cómo podemos empezar a configurar nuestras clases para que al momento de crear nuestros
objetos empecemos poner restricciones sobre cómo se deben utilizar e inicializar sus atributos.
Finalmente, podemos observar que cada clase realizar su labor, es decir, la clase Persona realiza las tareas respectivas al momento
de crear un objeto de tipo Persona, o la asignación de las variables para las clases hijas, y la clases hijas, en este caso la clase
Empleado realiza la inicialización de los atributos que su clase define, pero no duplica código o realiza tareas que no debe realizar,
cualquier tarea la delega a la clase Padre y/o los constructores correspondientes. De esta manera evitamos la duplicación de
código y comenzamos a crear diseños más elaborados y funcionales en la creación y codificación de nuestras clases.
Con lo que hemos visto hasta ahora, podemos darnos cuenta no solamente de cómo se configuran nuestras clases Java, sino también el orden en que se crean
los objetos Java.
En primer lugar se manda a llamar el constructor del objeto que estamos creando. Al comenzar a ejecutar este constructor, se hace una llamada implícita a
super( ), es decir, a la clase Padre.
Todas las clases en Java heredan de la clase Object según hemos comentado, por lo tanto todos los constructores en un momento u otro hacen una llamada a
super( ), y eventualmente termina llamando al constructor vacío de la clase Object. Este constructor es el encargado de reservar memoria entre varias tareas
más, sin embargo para esta lección basta con saber que es el constructor que se manda a llamar en todos los casos que se crea un objeto.
Una vez que termina de ejecutarse el constructor de la clase padre, se regresa el control al constructor que había iniciado la llamada, o que es a su vez el
constructor padre, y así hasta que la cadena de constructores se concluya. En pocas palabras los constructores hijos son los que inician la llamada, pero estos a
su vez en su primera línea de código, de manera directa o indirecta llaman al constructor de la clase padre. Si no es especifica nada, entonces la llamada es al
constructor vacío de la clase padre, es decir, super ( );
Una vez que el constructor vacío de la clase Padre termina de ejecutarse, se regresa el control al constructor de la clase que inicio la llamada y continua con la
ejecución de su código. Si ya se concluyó con la llamada de constructores entonces se regresa el controla al método que hizo la llamada a la construcción del
objeto respectivo.
Por ejemplo, en el código de nuestro ejemplo, el método main crea un objeto de la clase Empleado, pero esta a su vez tiene como clase padre a la clase
Persona, y la clase persona al ya no extender de ninguna otra clase de manera explícita, entonces extiende de manera implícita de la clase Object. Todas las
clases en Java si no especifican un extends en la definición de su clase, entonces podemos decir que su clase padre es la clase Object según hemos comentado.
Por lo tanto, la primer llamada que se realiza es al constructor de la clase Empleado, con 3 argumentos, es decir, Empleado(String, int, int). Este código vamos a
suponer que es el mismo de las láminas anteriores. Entonces, antes de hacer la asignación del atributo sueldo, lo primero que hace es hacer una llamada al
constructor de su clase Padre, es decir, al constructor de la clase Persona. Debido a que sí se está haciendo una llamada explícita por medio de super, entonces
se manda a llamar al constructor de la clase Persona con dos argumentos.
Este constructor de la clase Persona(String, int) supondremos que es el mismo código de las láminas anteriores, por lo tanto, se hace una llamada al constructor
sin argumentos con el uso de this( ). Y es constructor sin argumentos debido a que no hace una llamada explícita a super, entonces de manera implícita se llama
super( ), es decir al constructor de la clase Object. Una vez que termina este constructor de la clase object de ejecutar su código, regresa el control al
constructor vacío de la clase Persona( ) y continua una línea después de donde se hizo la llamada implícita a super( ). Y una vez que terminan de ejecutarse los
códigos de los constructores de la clase Persona, regresa el control al constructor de la clase Empleado, para finalmente concluir con la creación del objeto
Empleado, el cual ya ha inicializado todos los atributos tanto de la clase Empleado y de la clase Persona, según el proceso descrito anteriormente.
Esto es importante tenerlo en cuenta ya que cuando estamos programando nuestros constructores y considerando la inicialización de variables es importante
saber el orden en el que nuestros constructores serán ejecutados, así como la creación de las clases, sobre todo cuando estamos aplicando el concepto de
herencia.

Datos de Contacto:

Crear un ejercicio para aplicar el concepto de sobrecarga de
Constructores en Java. Al finalizar deberemos observar lo
siguiente:

El siguiente es un diagrama de Clases del ejercicio, creado con
la herramienta http://www.umlet.com/umletino/umletino.html:


package sobrecargaconstructores;
private int idPersona;

private int edad;
private static int contadorPersonas;
//Constructor sin argumentos y privado

//Asigna el idPersona
private Persona() {
this.idPersona = ++contadorPersonas;
}
//Constructor completo sobrecargado

public Persona(String nombre, int edad) {
//Se manda a llamar el constructor vacio para que se asigne el idPersona
this();
this.edad = edad;
}
@Override
public String toString() {
return "Persona{" + "idPersona=" + idPersona + ", nombre=" + nombre + ", edad=" + edad + '}';
}
}
Archivo Empleado.java:
public class Empleado extends Persona {
private double sueldo;
public Empleado(String nombre, int edad, double sueldo) {

super(nombre, edad); //Super debe ser la primera linea
this.sueldo = sueldo;
}
public double getSueldo() {

return sueldo;
}
public void setSueldo(double sueldo) {

this.sueldo = sueldo;
}
@Override
//Primero mandamos a llamar el método toString de la clase Persona
//para que podamos observar los valores de la clase Padre,
//y despues imprimimos los valores de la clase hija
return super.toString() + " Empleado{sueldo=" + sueldo + "}";
}
}
Archivo SobrecargaConstructores.java:
public class SobrecargaConstructores {

//El constructor vacío es privado, por lo que nos obliga a
//utilizar el único constructor público y por lo tanto
//proporcionar valores en los campos de nombre y edad
Persona p1 = new Persona("Lilia", 22);

System.out.println("Imprimimos el objeto p1");
System.out.println(p1);
//Creamos un nuevo objeto de tipo persona

Persona p2 = new Persona("Juan", 33);
System.out.println("\nImprimimos el objeto p2");
System.out.println(p2);
//Creamos un objeto empleado

Empleado e1 = new Empleado("Pedro", 29, 18000);
System.out.println("\nImprimimos el objeto e1");
}
}
Ejecutamos nuestro proyecto. El resultado es:

• Crear más variables tanto de objetos Persona, Empleado y

verificar resultados.

Sobrecarga de Constructores.
• Además vimos varios temas relacionados más, que tienen

que ver con el buen diseño de nuestras clases.
• Ya estamos empezando a aplicar varios temas que hemos

venido trabajando, así que es importante que vayan
quedando claros, ya que los seguiremos utilizando en las
siguientes lecciones.


lección.
Vamos a estudiar el tema de sobrecarga de métodos en Java.
La sobrecarga de métodos en Java es similar al tema de sobrecarga de Constructores, pero en este caso cualquier método puede ser
sobrecargado.
La sobrecarga de métodos es ofrecer más de una opción de alguno de los métodos definido en nuestras clases, con el objetivo de brindar más
opciones para el uso de nuestros métodos.
En la lámina mostrada podemos observar el ejemplo del método sumar. En primer lugar definimos un primer método sumar, el cual recibe
dos argumentos de tipo int, hasta aquí no existe la sobrecarga, ya que para que existe debe haber dos o más métodos con el mismo nombre
definidos en la clase.
Una de las reglas de la sobrecarga de métodos es que lo que observa el compilador para que un método cumpla con una sobrecarga válida es
que los tipos de los argumentos sea distinto a los del método ya definido, esto incluye el orden de los argumentos, pero en ningún caso el
compilador revisa que los nombres de los argumentos sea igual o no, de igual manera no revisa si el tipo de retorno es igual o no, es decir, que
el tipo de retorno tampoco importa al momento de agregar un método que cumpla con la sobrecarga.
Entonces, para que una sobrecarga sea válida debe cumplir con lo siguiente:
1) El nombre del método debe ser igual al método que se desea sobrecargar.
2) Los argumentos del método deben ser distintos al método que se desea sobrecargar, únicamente se revisa el tipo y el orden en que se
agregan, no se revisa el nombre del argumento.
3) El tipo de retorno no afecta si es igual o distinto al del método a sobrecargar.
4) El método a sobrecargar puede estar definido en nuestra clase o en alguna clase superior.
5) Los argumentos pueden ser de tipo primitivo o de tipo Object
En caso de aplicar alguna conversión de los tipos a utilizar, se aplicará la conversión automática superior que aplique, por ejemplo si hacemos
uso de dos variables de tipo long, y hacemos una llamada al método sumar, no se llamará al método con argumentos de tipo int, sino al
método sumar con argumentos de tipo double, ya que el tipo long se convertirá al tipo superior de manera automática, es decir al tipo
double, y quedará descartado el tipo int por ser un tipo de menores bits y menos capacitad para almacenar un dato de tipo long. Lo mismo
aplica para el concepto de objetos, aunque este tema lo veremos en el siguiente curso, en el tema de conversión de objetos.
Básicamente con esto es suficiente para saber qué es la sobrecarga y cómo implementarla en Java, a continuación realizaremos un ejercicio.

Datos de Contacto:

Con este ejercicio pondremos en práctica el concepto de
sobrecarga de Métodos en Java. Al finalizar deberemos


Creamos la clase Operaciones:

Archivo Operaciones.java:
package sobrecargametodos;
public class Operaciones {
//Metodo sumar
public static int sumar(int a, int b) {
System.out.println("metodo sumar (int, int)");
return a + b;
}
//Sobrecarga del metodo sumar

public static double sumar(double a, double b) {
System.out.println("metodo sumar (double, double)");
return a + b;
}
public static double sumar(int a, double b) {

System.out.println("metodo sumar (int, double)");
return a + b;
}
public static double sumar(double a, int b) {

System.out.println("metodo sumar (double, int)");
return a + b;
}
Archivo SobrecargaMetodos:
package sobrecargametodos;
public class SobrecargaMetodos {

System.out.println("Resultado 1: " + Operaciones.sumar(3, 4));
System.out.println("Resultado 2: " + Operaciones.sumar(5, 4.1));
System.out.println("Resultado 3: " + Operaciones.sumar(7.1, 3));
System.out.println("Resultado 4: " + Operaciones.sumar(2.2, 6.8));
//¿Cual método se manda llamar?

System.out.println("Resultado 5: " + Operaciones.sumar(3, 1L));//la L o l es de long
//¿Cual método se manda llamar?

System.out.println("Resultado 6: " + Operaciones.sumar(3F, 'A'));//La F o f es de Float
}



sobrecarga de métodos en Java.
• Este tema es muy similar a la sobrecarga de constructores,

pero como hemos observado hay diferencias importantes y
bien vale la pena tener bien claro cada uno de estos
conceptos.


Vamos a estudiar el tema de paquetes en Java.
Los paquetes en Java permiten organizar nuestras clases. Podemos pensar en los paquetes como cualquier
carpeta o folder que creamos para organizar documentos, archivos, fotos o cualquier tipo de información.
En Java lo que organizamos son clases, y básicamente nos permite agrupar clases ya sea por su función,
por herencia, o por cualquier característica que deseemos, lo importante es que tengamos una
organización de nuestras clases, ya que solo en la versión estándar de Java SE encontramos más de 4000
clases, y por lo tanto es importante definir la forma en que organizaremos nuestras clases.
De igual manera, un proyecto en Java suele tener cientos o miles de clases, por lo tanto debemos organizar
nuestras clases de la mejor forma, normalmente por la función que estas clases desempeñan en nuestro
programa.
Al tener tantas clases, es normal que existan clases con el mismo nombre, sin embargo como cada clase
pertenece a un paquete distinto, los paquetes también nos servirán para evitar problemas de nombres
entre clases. Por ejemplo existen muchas clases Date en la versión estándar de Java, y para poder
distinguir qué clase queremos utilizar debemos especificar el paquete Java donde se encuentra esta clase.
Más adelante veremos un ejemplo de cómo hacer uso de los paquetes, y cómo Java nos permite utilizar las
clases que pertenecen a dichos paquetes.
Otro de los usos de los paquetes es que limitan el acceso a los métodos o atributos de nuestras clases, ya
que se limita según los modificadores de acceso que se utilicen. Este concepto lo veremos a detalle en el
siguiente curso.
En la versión estándar de Java existen más de 4000 clases, por lo que ya existe un gran número de
paquetes definidos, además de los que nosotros definamos. Todas estas clases están disponibles para ser
utilizadas en nuestros programas Java, y más adelante veremos cómo podemos acceder a estas clases.
El nombre de los paquetes en Java siguen un estándar.
El nombre del dominio no considera www, sólo es el nombre del dominio.

Esto asegura que este nombre utilizado en internet es único. Si no tuviéramos
un dominio, podemos asignar un nombre al proyecto y crear imaginariamente
nuestro nombre de internet. Ej. com.miproyecto, y de esta manera si hubiera
algún conflicto de nombres con otro proyecto, basta con modificar el nombre
del proyecto a alguno que no tenga conflicto. La idea es que sigamos este
estándar aunque no tengamos un dominio en internet, ya que este dominio
web no es necesario que exista en internet, es sólo para evitar conflictos de
nombre lo más posible.
Sin embargo podemos observar en la lámina un ejemplo del dominio

globalmentoring.com.mx, el cual si queremos utilizarlo en nuestros proyectos
Java podríamos usarlo, en primer lugar invirtiendo el orden del nombre del
dominio, y posteriormente agregando el nombre de nuestro proyecto, con el
objetivo de tener un nombre de paquete único. También vemos algunos
ejemplos si tuviéramos un proyecto, y si ese proyecto tuviera subpaquetes,
para distintas partes del mismo proyecto.
Podemos observar en el ejemplo que primeramente creamos una clase llamada Utileria, esta clase la
estamos agregando a un paquete llamado com.gm, pero puede ser cualquier nombre que deseen.
Una vez que hemos agregado una o más clases a este paquete, entonces creamos una clase en un paquete
distinto. En este caso creamos la clase EjemploPaquetes en el paquete por default de Java, es decir, en
ningún paquete. Cabe señalar que esta práctica no se recomienda, solo es para realizar el ejercicio. Java
recomienda que todas las clases que creemos deben estar dentro de en un paquete.
Ahora, para poder utilizar la clase Utileria definida en el paquete com.gm, lo que debemos hacer es utilizar
la palabra import, la cual la podemos utilizar de dos maneras, una es importando todas las clases usando el
*, o la otra es especificando el nombre de la clase, es decir: import com.gm.Utileria. Sin embargo esta
última opción nos obliga a hacer un import por cada clase que deseemos utilizar del paquete com.gm, y si
fueran muchas clases serian muchas líneas de código, por lo que en muchas ocasiones la notación import
com.gm.* es la más utilizada. Cabe mencionar que el import no afecta la memoria, ya que no es que se
carguen todas las clases de un paquete en memoria, una clase de carga en memoria hasta que se usa el
nombre de la misma dentro del programa y no antes.
Finalmente podemos ver cómo estamos utilizando el método estático llamado imprimir, el cual pertenece
a la clase Utileria. Observamos que ya no estamos indicando a qué paquete corresponde dicha clase, ya
que hemos hecho el import. Sin embargo si hubiera más de una clase llamada Utileria, podríamos eliminar
el import e inidicar en la línea de código donde vamos a utilizar la clase, directamente el paquete al cual
corresponde la clase, quedando com.gm.Utileria.imprimir(“Hola”); con esto sabríamos exactamente a qué
paquete corresponde la clase que estamos utilizando.
En Java es posible importar los métodos estáticos a utilizar, de esta manera

simplificamos la sintaxis en los métodos estáticos dentro de nuestro código.
En el ejemplo mostrado podemos observar que la clase Utileria y el paquete al que

pertenecen son los mismos que en el ejemplo anterior, pero debido a que el
método imprimir es un método estático, podemos aprovechar la sintaxis de import
static que nos brinda java para importar el método estático a utilizar, y de esta
manera se simplifica la sintaxis del uso del método imprimir, ya que como podemos
observar el método imprimir ya no debe indicar a qué clase pertenece, sino que es
suficiente con indicar el nombre del método, ya que en el import static ya se ha
indicado que pertenece a la clase Utileria.
En la tabla mostrada, podemos observar algunos de los paquetes Java más

comunes de la versión estándar. El más importante es el paquete java.lang, el cual
contiene las clases core del lenguaje Java, tales como la clase Object, que es la clase
de la cual descienden todas las clases en Java, entre varias clases más. Cabe señalar
que no es necesario hacer import de ningún de las clases de este paquete, ya que
es el único que se importa de manera automática por la importancia que tienen
estas clases en la compilación y ejecución de nuestras clases Java.
Existen otros paquetes los cuales son también muy importantes, tales como el
paquete java.util, java.net, y java.awt, java.ui y java.applet, entre muchos paquetes
más. Conforme vayamos avanzando a lo largo del curso y cursos posteriores
estaremos estudiando varias de las clases de estos paquetes.


Crear un programa para practicar en manejo paquetes en Java.


Creamos un paquete:

( )
Creamos un paquete:

Creamos una clase dentro del nuevo paquete:

( )
Creamos una clase dentro del nuevo paquete:

Archivo Utileria.java:
//Definicion del paquete
package com.gm;
public class Utileria {

public static void imprimir(String s){
System.out.println("Imprimiento mensaje: " + s);
}
}

Archivo EjemploPaquetes.java:
package ejemplopaquetes;
import com.gm.Utileria;
public class EjemploPaquetes {

Utileria.imprimir("Juan");
}
}


Archivo EjemploPaquetes.java:
package ejemplopaquetes;
//Importamos el metodo estatico a utilizar

import static com.gm.Utileria.imprimir;
public class EjemploPaquetes {

imprimir("Hola");
}
}


• Con este ejercicio hemos puesto en práctica lo más básico
del manejo de paquetes en Java. Conforme avancemos
podremos ir aprendiendo más cuestiones acerca de este
tema, sobre todo temas que tienen que ver con la herencia y
los limites al manejar paquetes.
• Para más información de los paquetes en Java:
• https://docs.oracle.com/javase/tutorial/java/package/packages.html


lección.
Vamos a estudiar el tema de la palabra final en Java.
La palabra final afecta no solamente a variables, sino también es posible utilizarlo en métodos y en clases. En cada
uno tiene un significado distinto que es lo que estudiaremos en esta lección.
En primer lugar veremos lo que implica utilizar la palabra final al definir una variable.
Es posible inicializar una variable final, pero una vez que se ha inicializado su valor, ya no es posible modificarlo, sin
embargo recordemos que las variables que almacenan referencias de objetos no contienen el valor en si del objeto,
sino solo de la referencia donde se ubica el mismo. Esto quiere decir que es posible cambiar el estado del objeto,
pero no la referencia almacenada en la variable que se creo indicando que es final. En pocas palabras se dice que la
palabra final es como crear una constante en Java, sin embargo debemos tomar en cuenta lo mencionado respecto a
los objetos.
Debido a que la palabra final es como crear una constante, es muy común que se combine con la palabra static para
poderla acceder directamente en lugar de crear una instancia de la clase para poder usar la variable final, en cambio
al definir una variable como public static y final podemos accederla directamente indicando el nombre de la clase y
posteriormente el nombre de la variable, y más aún, si agregamos el import static podemos utilizar directamente el
nombre de la constante como veremos más adelante. Un ejemplo muy común es el uso de la constante PI, la cual se
encuentra definida en la clase Math. Esta variable si viéramos su código está definida como public final y static, por
lo tanto podemos acceder escribiendo: Math.PI y esto nos regresará el valor de 3.1416…
Cuanto estamos hablando de utilizar la palabra final en la definición de un método, básicamente estamos diciendo
que una subclase no puede sobreescribir el comportamiento del método de la clase padre, es decir, que así como lo
hereda debe utilizarlo y no puede modificarlo. El tema de sobreescritura lo veremos a detalle en el siguiente curso.
Y finalmente, cuando hablamos de clases, cuando definimos una clase como final, lo que indicamos es que no se
puede crear clase que extienda de esta clase, es decir, no tendrá clases hijas. Es como indicar que esta será la última
clase en la jerarquía de clases para esta clase en particular.


Crear un ejercicio para poner en práctica el uso de la palabra
final. Al finalizar deberemos observar lo siguiente:


Creación de clase Persona:

package ejemplopalabrafinal;

return nombre;
}

}
}

Creación de clase ClaseFinal:

Archivo ClaseFinal.java:
//Clase marcada como final

public final class ClaseFinal {
//Variables marcadas como finales

public static final int varPrimitivo = 10;
public static final Persona persona = new Persona();
//Metodo final, estudiaremos el tema de sobreescritura en otra leccion

public final void metodoFinal(){
}
}
//Marca error: No se puede heredad de una clase final

//class ClaseHija extends ClaseFinal{ }
Archivo EjemploPalabraFinal.java
public class EjemploPalabraFinal {

//Marca error, no se puede modificar el valor de una variable final
//ClaseFinal.persona = 10;
//No es posible cambiar la refEjeerencia de la variable persona

//ClaseFinal.persona = new Persona();
System.out.println("Nombre persona:" + ClaseFinal.persona.getNombre());
//Pero si es posible cambiar el estado del objeto

//referenciado por la variable persona
ClaseFinal.persona.setNombre("Otro");
System.out.println("Nombre persona:" + ClaseFinal.persona.getNombre());

}
}

• Revisar cada uno de los casos, excepto el manejo de métodos

y la palabra final, ya que este tema lo veremos en otro
capitulo.

• Con este ejercicio hemos puesto en práctica el uso de la
palabra final.
• Hemos visto que es posible utilizar la palabra final en 3

ámbitos: al declarar una variable, en un método y en una
clase, y cada uno tiene sus detalles. Más adelante veremos a
fondo del tema de sobreescritura, y allí retomaremos el uso
de la palabra final al evitar la sobreescritura, concepto que
revisaremos en el siguiente curso.


Vamos a estudiar el tema de BlueJ y Java.
BlueJ.org es un proyecto que creado con el objetivo de facilitar el

entendimiento de varios conceptos de la programación orientada a
objetos, y nos permite observar gráficamente varios conceptos que de
otra manera sería difícil de entender, y sólo con la experiencia
terminaríamos por entenderlo.
Sin embargo este tipo de software nos facilita entenderlo más

rápidamente y de una manera más divertida. Debemos tener en cuenta
que este no es un ambiente real de desarrollo y solamente se usa con el
objetivo de aclarar algunos conceptos de Java, pero nunca reemplazará a
un proyecto real ni es su intención.
Crearemos algunos ejercicios y retomaremos varios de los que ya hemos

realizado hasta el momento con el objetivo de que observen cómo se
visualizan las clases y conceptos que hemos trabajado desde el entorno
de BlueJ.

Datos de Contacto:

Curso de fundamentos de java
fundamentos de java Hibernate Framework

Poner en práctica la creación de Clases en BlueJ. Al finalizar

Vamos a crear un nuevo proyecto:

Vamos a crear un nuevo proyecto. Seleccionamos alguna
carpeta donde deseamos crear el proyecto, y posteriormente
proporcionamos el nombre del proyecto:

Creamos una nueva clase.

Creamos una nueva clase llamada Persona. Damos doble clic
sobre la clase llamada Persona:

//Variables Privadas
private String apellido;
//Constructor vacio
public Persona() {}
public Persona(String nombre, String apellido) {

this.apellido = apellido;
}

return nombre;
}

}
public String getApellido() {

return apellido;
}
public void setApellido(String apellido) {

this.apellido = apellido;
}
}
Compilamos la clase Persona:

Damos click derecho en la clase y creamos un objeto:

Damos doble click sobre el objeto creado persona1:

Cambiamos el valor del atributo nombre. Damos click derecho
sobre el objeto persona1 y seleccionamos el método deseado:

Cambiamos el otro atributo. Damos click derecho sobre el
objeto persona1 y seleccionamos el método deseado:

• Crear más objetos de tipo persona y modificar los valores de
cada atributo.
• Crear un objeto con el constructor vacío y otro con el

constructor con dos argumentos y verificar resultados.

Con este ejercicio pudimos observar cómo crear un objeto
gráficamente, así como modificar el estado del objeto llamando
a los métodos respectivos.
Existen más formas de crear objetos en BlueJ, pero esto lo

veremos en otros ejercicios.
Para más información:
http://www.bluej.org/


Vamos a estudiar el tema de Arreglos en Java.
En Java la estructura de datos más simple es el arreglo. Un arreglo de datos básicamente es

un conjunto de información, la cual nos permite agrupar información normalmente de un tipo en
particular.
Por ejemplo, en la figura podemos observar dos arreglos, uno de tipo enteros y otro de tipos
Persona. Es decir, que podemos declarar arreglos que contengan cualquier tipo de datos, ya
sea de tipos primitivos o de tipo Object.
En el primer caso, el arreglo contiene 8 elementos (length), los cuales se numeran del
elemento 0 al elemento 7. Esto quiere decir que los arreglos en Java inician en el índice 0, y el
último elemento tendría el índice número de elementos menos uno.
Tenemos por otro lado el arreglo de tipo Persona, el cual contiene 7 elementos (length), y por
ello el índice va de 0 a 6, según se observa en la figura.
No todos los elementos del arreglo deben contener valores. Por ejemplo, si el arreglo de
enteros fuera de 10 elementos, pero solo tuviera 7 valores, los 3 últimos valores tendrían su
valor por default del tipo declarado, en este caso como es de tipo int, el valor por default para el
tipo int es 0.
En el caso del arreglo de tipo object si fuera de 10 elementos, y tuviera solo 5 objetos de tipo
persona definidos, entonces los 5 restantes su valor serial null, ya que ese es el tipo por default
para los tipo Object.
A continuación veremos la sintaxis para el manejo de arreglos.
En esta lámina podemos observar la sintaxis para la declaración de un arreglo de

una dimensión. En la siguiente lección veremos la declaración de un arreglo de dos
dimensiones.
Básicamente es como declarar una variable excepto que vamos a utilizar los
corchetes [], los cuales se pueden utilizar en dos partes, ya sea antes del nombre
de la variable o después del nombre de la variable, por eso se muestran las dos
opciones en cada declaración.
Declarar un arreglo es igual a declarar variables, podemos declarar arreglos que

almacenen tipos primitivos o que almacenen referencias a objetos. En la lámina
mostramos ambos casos, primero mostramos dos ejemplos de tipo primitivo, uno de
tipo int y otro de tipo boolean. Posteriormente mostramos la declaración de dos
arreglos que almacenarán referencias de objetos de tipo Persona y de tipo String.
Debido a que los arreglos es una colección de datos, normalmente el nombre de un

arreglo es en plural, para que fácilmente con solo leer la variable reconozcamos
que se trata de una colección de datos, y en este caso de un arreglo, aunque más
adelante veremos que se puede tratar no solamente de arreglos, sino de otras
estructuras de datos.
Lo mostrado en la lámina es únicamente la declaración de la variable, veremos a

continuación como inicializar un arreglo de una dimensión, ya que hasta el
momento con sólo declarar una variable de tipo arreglo la JVM no sabe cuan largo
es este arreglo, para ello debemos inicializarlo, veamos como.
Partiendo de las variables definidas en la lámina anterior, en esta

lámina vemos la sintaxis para instanciar arreglos de una dimensión
según el tipo de dato que estemos utilizando.
La sintaxis es muy similar a instanciar una variable de tipo object, y de

hecho esta es una de las características de Java, incluso los arreglos o
cualquier tipo en Java que almacena una referencia hereda de la clase
Object de manera directa o indirecta, por lo tanto los arreglos también
descienden de la clase Object.
Sin embargo, la diferencia con instanciar un objeto normal a un arreglo,

es que en un arreglo indicamos el número de elementos máximo que
contendrá dicho arreglo. Previamente en la definición de la variable ya
se indicó que tipo es el que va almacenar, y ahora debemos indicar
que crearemos un objeto de cierto tipo y que contendrá un número de
elementos según se indique.
Podemos observar en la lámina varios ejemplos de inicialización de

arreglos según el tipo de datos que elegimos. A continuación veremos
cómo inicializar los elementos de un arreglo.
En la lámina podemos observar la inicialización de los elementos de un arreglo de una

dimensión. Lo que debemos hacer es para ir agregando elementos a un arreglo, es
seleccionar uno por uno los índices que queremos ir inicializando.
Por ello, es importante saber que el índice cero es el primer elemento del arreglo, y el
último elemento de un arreglo lo podemos obtener con la propiedad length menos un
elemento, por ejemplo si escribimos: enteros.lenght -1 nos devolverá el último índice del
arreglo que podremos ocupar. Si nos pasamos del índice máximo y queremos agregar un
elemento fuera de la cantidad máxima de elementos nos arrojará un error, por ello
debemos saber cual es el máximo número de elementos con el código mencionado.
Podemos observar en la lámina varios ejemplos de cómo agregar elementos a nuestro

arreglo. Podemos agregarlos de manera manual, es decir, uno a uno cada elemento, o
podemos ir agregando los elementos de manera más dinámica utilizando un contador de
elementos que han sido agregados, de tal forma que podamos saber si ya hemos llegado
al límite de elementos agregados o no.
En esta lámina podemos observar más claramente que no siempre estarán llenos todos
los elementos de un arreglo, por ejemplo si el arreglo de enteros es de 10 elementos,
entonces sólo hemos llenado 2 de los 10 elementos disponibles, esto quiere decir que 8
elementos tendrán el valor por default, en este caso el valor de 0. Por ello en muchas
ocasiones será conveniente tener un contador para poder conocer cuántos elementos se
han inicializado en nuestro arreglo, lo cual es distinto al número de elementos máximo
que soporta nuestro arreglo.
En el ejercicio de esta lección veremos cómo inicializar los elementos de nuestros

arreglos.
Para leer o extraer los elementos almacenados en un arreglo basta

con indicar el nombre del arreglo e indicar el índice del elemento que
queremos extraer, esto regresará el elemento del índice indicado.
Es importante no pasarnos del numero máximo de elementos, de lo

contrario regresará un error.
Podemos observar en la lámina varios ejemplos con arreglos que

almacenan tipos primitivos o tipos Object, en ambos casos la sintaxis
es la misma, sólo debemos tener una variable que reciba el valor
extraído del arreglo respectivo según el índice especificado. Más
adelante veremos ejemplos de cómo extraer los elementos utilizando
un ciclo for o while para recorrer cada uno de los elementos del
arreglo.
Existe otra forma de declarar arreglos, y al mismo tiempo instanciarlo e

inicializar cada uno de sus elementos. Esta es una sintaxis distinta en
la forma en que se asignan los valores.
Podemos observar en la lámina varios ejemplos, tanto con tipos

primitivos, así como tipo Object. Y lo que podemos observar es que en
la misma línea de código se declara la variable, se instancia el arreglo
y se inicializa cada uno de sus valores.
Sin embargo, esta sintaxis no siempre es posible utilizarla ya que

necesitaríamos saber de antemano todos los elementos que van a ser
almacenados en el arreglo, y en muchas ocasiones no tenemos esta
información desde un inicio, pero si tenemos esta información antes de
crear nuestro arreglo, entonces es posible utilizar esta sintaxis
simplificada.
Podemos observar en la lámina algunos ejemplos para el uso de arreglos.
Desde la declaración (líneas 5 y 16), el instanciamiento (líneas 7 y 17), la

inicialización de valores (líneas 9-10 y 18-19), y finalmente la lectura de
los valores (líneas 13-14 y 21-22).
Podemos observar que no todos los valores del arreglo están

inicializados, por lo que los valores que no se hayan inicializado su valor
será el valor por default del tipo declarado, en el caso del arreglo de tipo
int el valor por default es 0 y en el caso del objeto tipo Persona su valor
por default será null.
Más adelante realizaremos este ejercicio para poner en práctica estos

conceptos.
Finalmente veremos un ejemplo de la notación simplificada, y

aprovecharemos para mostrar cómo iterar un arreglo con la ayuda de algún
ciclo como puede ser el ciclo for.
En primer lugar vemos un ejemplo del uso de la notación simplificada (línea

6). En este caso es un arreglo de tipo String, y en la misma línea
instanciamos el arreglo e inicializamos los valores del arreglo. En este caso
no hay que indicar el número de elementos que contendrá el arreglo, este
número se obtendrá directamente del número de elementos que se
agreguen en la inicialización del arreglo. Cabe aclarar que en esta estructura
de datos no es posible hacer más grande o más pequeño el arreglo una vez
declarado o como en este caso una vez inicializado. Sin embargo veremos
en el siguiente curso el tema de colecciones, donde veremos estructuras
como un ArrayList los cuales son estructuras que pueden crecer
dinámicamente.
Una vez que hemos definido cuántos elementos tendrá el arreglo, la

propiedad length nos regresará el número máximo de elementos. Por ello es
posible combinar un ciclo for, y utilizar un contador, en este caso la variable
entera i, para ir iterando el número de elementos del arreglo, y el fin de este
ciclo será cuando este contador i sea menor que el largo del arreglo. Y con
esto terminará el recorrido de cada uno de los elementos del arreglo.
Veremos más adelante la ejecución de este código para poner en práctica

estos conceptos.

Datos de Contacto:


Poner en práctica el concepto de Arreglos de una dimensión en
Java. Al finalizar deberemos observar lo siguiente:



( )

package com.gm.dominio.arreglos;

}

return nombre;
}

}
@Override
return "Persona{" + "nombre=" + getNombre() + '}';
}
}
Archivo EjemploArreglos.java:
package ejemploarreglos; //Imprimimos los valores a la salida estandar
//4. leemos los valores de cada elemento del arreglo
import com.gm.dominio.arreglos.Persona; System.out.println("");
System.out.println("Arreglo personas indice 0: " + personas[0]);
public class EjemploArreglos { System.out.println("Arreglo personas indice 1: " + personas[1]);
System.out.println("Arreglo personas indice 2: " + personas[2]);
//1. Declaramos un arreglo de enteros //1. Arreglo de String, notación simplificada
int edades[]; String nombres[] = {"Sara", "Laura", "Carlos", "Carmen"};
//2. Instanciamos el arreglo de enteros //Imprimimos los valores a la salida estandar
edades = new int[3]; //2. Iteramos el arreglo de String con un for
//3. Inicializamos los valores del arreglo de enteros System.out.println("");
edades[0] = 30; for (int i = 0; i < nombres.length; i++) {
edades[1] = 15; System.out.println("Arreglo String indice " + i + ": " +
edades[2] = 20; nombres[i]);
}
//Imprimimos los valores a la salida estandar }
//4. leemos los valores de cada elemento del arreglo }
System.out.println("Arreglo enteros indice 0: " + edades[0]);
//1. Declaramos un arreglo de enteros

Persona personas[];
//2. Instanciamos el arreglo de enteros
personas = new Persona[4];
//3. Inicializamos los valores del arreglo de enteros
personas[0] = new Persona("Juan");
personas[1] = new Persona("Karla");
personas[2] = new Persona("Pedro");


• Modificar y agregar más valores a los arreglos y probar con

estos nuevos valores.

arreglos de una dimensión en Java.
• Hemos visto como declarar, instanciar, inicializar, asignar y

leer datos de un arreglo.
• Además vimos cómo iterar por medio de un ciclo for los

elementos de un arreglo. En la siguiente lección veremos
cómo podemos trabajar con arreglos de dos dimensiones.


Vamos a estudiar el tema de Matrices en Java.
Otra estructura de datos en Java que podemos utilizar es una matriz. A diferencia
de un arreglo de una dimensión, una matriz podríamos verla como dos arreglos,
un arreglo maneja los renglones y otro arreglo las columnas, y al juntarlos
obtenemos una matriz. Sin embargo veremos que existen muchas cosas
similares con un arreglo, y una vez entendido el concepto de arreglo es más
sencillo entender el concepto de matriz.
En la figura podemos observar una matriz de 4 renglones por 7 columnas, de tipo

enteros, sin embargo puede ser de cualquier tipo que definamos.
Podemos recuperar el largo de los renglones con el código nombreArreglo.length

y podemos obtener el largo de las columnas escribiendo nombreArreglo[0].length,
es decir, que con cualquier renglón válido seleccionado podemos obtener el largo
de las columnas. Esto nos va a servir posteriormente para iterar por medio de un
ciclo for anidado cada uno de los elementos de la matriz.
De igual manera que un arreglo, no todos los elementos de una matriz deben
contener valores. Los valores que no tengan un valor asignado tendrán el valor
por default según el tipo de datos definido para la matriz.
A continuación veremos la sintaxis para declarar una matriz.
En esta lámina podemos observar la sintaxis para la declaración de una matriz.

Básicamente es como declarar un arreglo excepto que vamos a utilizar doble
corchete [][], los cuales se pueden utilizar en dos partes, ya sea antes del nombre
de la variable o después del nombre de la variable, por ello se muestran las dos
opciones en cada declaración.
Declarar una matriz es igual a declarar variables, podemos declarar matrices que
almacenen tipos primitivos o que almacenen referencias a objetos. En la lámina
mostramos ambos casos, primero mostramos dos ejemplos de tipo primitivo, uno de
tipo int y otro de tipo boolean. Posteriormente mostramos la declaración de dos
matrices que almacenarán referencias de objetos de tipo Persona y de tipo String.
Debido a que una matriz es una colección de datos , normalmente el nombre de

una matriz es en plural, para que fácilmente con solo leer el nombre de la variable
reconozcamos que se trata de una colección de datos, aunque más adelante
veremos que se puede tratar no solamente de arreglos o matrices, sino de otras
estructuras de datos.
Lo mostrado en la lámina es únicamente la declaración de la variable, veremos a

continuación como inicializar una matriz, ya que hasta el momento con sólo declarar
una variable de tipo matriz la JVM no sabe cuan largo y ancho es la matriz, para
ello debemos inicializarlo, veamos como.
Partiendo de las variables definidas en la lámina anterior, en esta

lámina veremos la sintaxis para instanciar una matriz según el tipo de
dato que estemos utilizando.
La sintaxis es muy similar a instanciar una variable de tipo object, y de

hecho esta es una de las características de Java, incluso las matrices
o cualquier tipo en Java que almacena una referencia hereda de la
clase Object de manera directa o indirecta, por lo tanto las matrices
también descienden de la clase Object.
Sin embargo, la diferencia con instanciar un objeto normal a una

matriz, es que en un arreglo indicamos el número de elementos
máximo que contendrá dicha matriz, tanto en número de renglones,
como en el número de columnas. Previamente en la definición de la
variable ya se indicó que tipo es el que va almacenar, y ahora
debemos indicar que crearemos un objeto de cierto tipo y que
contendrá un número de renglones y columnas según se indique.
Podemos observar en la lámina varios ejemplos de inicialización de

matrices según el tipo de datos que elegimos. A continuación veremos
cómo inicializar los elementos de una matriz.
En la lámina podemos observar la inicialización de los elementos de una matriz. Lo que debemos hacer para ir
agregando elementos a una matriz, es seleccionar un renglón y una columna con los índices respectivos que
queremos ir inicializando.
Por ello, es importante saber que a diferencia de un arreglo, en una matriz utilizaremos dos índices para
determinar la posición de un elemento, y que los primeros índices tanto del renglón como de la columna inician
en cero. También es importante saber que cuando indicamos una posición primero se indica el renglón y
después la columna, siempre en ese orden. Por ejemplo, el primer elemento de una matriz será el elemento
[0][0] y el largo de una matriz realmente son dos, el primero lo determinaremos por el nombreMatriz.length lo
que nos regresa el largo de renglones, y posteriormente podemos saber el largo de las columnas
seleccionando cualquier renglón, por ejemplo: nombreMatriz[0].length.
Al igual que en un arreglo, sólo podemos agregar elementos hasta el máximo de elementos menos uno, por
ejemplo, si son renglones, seria nombreMatriz.lenght -1 y si fuera el máximo de columnas sería
nombreMatriz[i].lenght -1, donde i es el renglón que se está trabajando. Si nos pasamos del índice máximo
tanto en renglones o columnas y queremos agregar un elemento fuera de la cantidad máxima de elementos
nos arrojará un error, por ello debemos saber cual es el máximo número de elementos tanto en renglones
como en columnas.
Podemos observar en la lámina varios ejemplos de cómo agregar elementos a nuestra matriz. Podemos
agregarlos de manera manual, es decir, uno a uno cada elemento, o podemos ir agregando los elementos de
manera más dinámica utilizando dos contadores de elementos que han sido agregados, tanto para los
renglones como para las columnas, de tal forma que podamos saber si ya hemos llegado al límite de
elementos agregados o no.
En esta lámina podemos observar más claramente que no siempre estarán llenos todos los elementos de una
matriz, por ejemplo si la matriz de enteros es de 2 renglones por 2 columnas, entonces sólo hemos llenado 2
de los 4 elementos disponibles, esto quiere decir que 2 elementos tendrán el valor por default, en este caso el
valor de 0. Por ello en muchas ocasiones será conveniente tener contadores para poder conocer cuántos
elementos se han inicializado en nuestra matriz, lo cual es distinto al número de elementos máximo que
soporta nuestra matriz tanto en los renglones como en las columnas disponibles de la matriz.
En el ejercicio de esta lección veremos cómo inicializar los elementos de nuestras matrices.
Para leer o extraer los elementos almacenados en una matriz basta

con indicar el nombre de la matriz e indicar dos índices, tanto el
renglón como la columna del elemento que queremos extraer, esto
regresará el elemento de los índices proporcionados.
Es importante no pasarnos del numero máximo de elementos, tanto en

renglones como en columnas, de lo contrario regresará un error.
Podemos observar en la lámina varios ejemplos con matrices que

almacenan tipos primitivos o tipos Object, en ambos casos la sintaxis
es la misma, sólo debemos tener una variable que reciba el valor
extraído de matriz respectiva según los índices especificados. Más
adelante veremos ejemplos de cómo extraer los elementos utilizando
un ciclo for para recorrer cada uno de los elementos de una matriz.
Existe otra forma de declarar matrices, y al mismo tiempo instanciar e

inicializar cada uno de sus elementos. Esta es una sintaxis distinta en
la forma en que se asignan los valores.
Podemos observar en la lámina varios ejemplos, tanto con tipos

primitivos, así como tipos Object. Y lo que podemos observar es que
en la misma línea de código se declara la variable, se instancia la
matriz y se inicializa cada uno de sus valores.
Sin embargo, esta sintaxis no siempre es posible utilizarla ya que

necesitaríamos saber de antemano todos los elementos que van a ser
almacenados en la matriz, y en muchas ocasiones no tenemos esta
información desde un inicio, pero si tenemos esta información antes de
crear nuestra matriz, entonces es posible utilizar esta sintaxis
simplificada.
Podemos observar en la lámina un ejemplo para el uso de matrices
Desde la declaración (línea 5), el instanciamiento (línea 7), la inicialización

de valores (líneas 9-14), y finalmente la lectura de los valores (líneas 18-
23).
Podemos observar que en este caso, todos los valores del arreglo están
inicializados, sin embargo si hubiera valores que no se hayan inicializado
su valor será el valor por default del tipo declarado, en el caso del arreglo
de tipo int el valor por default es 0 y en el caso del objeto tipo Persona su
valor por default será null ya que es un tipo Object.
Más adelante realizaremos este ejercicio para poner en práctica estos

conceptos.
Finalmente veremos un ejemplo con una matriz de tipo String utilizando la notación simplificada, y
aprovecharemos para mostrar cómo iterar los elementos de una matriz con la ayuda de un ciclo for
anidado. Un ciclo for anidado es simplemente un ciclo for dentro de otro ciclo for. En este caso
realizaremos esta anidación para poder recorrer cada uno de los elementos de la matriz.
En primer lugar vemos un ejemplo del uso de la notación simplificada (línea 6). En este caso es una
matriz de tipo String, y en la misma línea instanciamos la matriz e inicializamos los valores de la
misma. En este caso no hay que indicar el número de renglones o columnas que contendrá la matriz,
este número se obtendrá directamente del número de elementos que se agreguen en la inicialización
de la matriz. Cabe aclarar que en esta estructura de datos no es posible hacer más grande o más
pequeña la matriz una vez declarado o como en este caso una vez inicializado. Sin embargo veremos
en el siguiente curso el tema de colecciones, donde veremos estructuras como un ArrayList los cuales
son estructuras que pueden crecer dinámicamente.
Una vez que hemos definido cuántos elementos tendrá la matriz, podemos obtener el no. de
renglones y de columnas de nuestra matriz. Así que para comprobar estos valores, mandamos a
imprimir el número de renglones con el código nombres.length (línea 9), y el número de columnas con
el código nombres[0].length (línea 11). Por ello es posible combinar dos ciclos for, y utilizando dos
contadores, en este caso las variables i y j, iremos iterando cada uno de los elementos de la matriz.
El primer ciclo, el más externo recorre los renglones de la matriz, y el ciclo más interno recorre las
columnas de la matriz. Por ello en la salida de nuestra consola, observaremos que los primeros 3
valores el valor del índice del renglón se mantiene fijo, mientras que índice de la columna se va
moviendo hasta que se acaba de iterar las columnas para ese renglón seleccionado. El fin del ciclo
más interno será cuando hayamos iterado todas las columnas para el renglón seleccionado, según la
condición del ciclo for interno: j < nombres[i].length (línea 16). Recordemos que la variable i controla
los renglones, y la variable j controla las columnas. Finalmente el ciclo más externo se detendrá
cuando se hayan revisado todos los renglones de la matriz, según la condición del ciclo for externo: i
< nombres.length (línea 15). Con esto habremos iterado todos los renglones, así como cada
columna de cada renglón seleccionado, y por consiguiente todos los elementos de la matriz.
Veremos más adelante la ejecución de este código para poner en práctica estos conceptos.

Datos de Contacto:


Poner en práctica el concepto de Matrices en Java. Al finalizar



( )

package com.gm.dominio.matrices;

}

return nombre;
}

}
@Override
return "Persona{" + "nombre=" + getNombre() + '}';
}
}
Archivo EjemploMatrices.java:
package ejemplomatrices;
//3. leemos los valores de cada elemento de la matriz con un ciclo for
import com.gm.dominio.matrices.Persona; anidado
System.out.println("");
public class EjemploMatrices { for (int i = 0; i < personas.length; i++) {
for(int j= 0; j < personas[i].length; j++){
public static void main(String[] args) { System.out.println("Matriz personas indice : " + i + "-"+ j + ": " +
//1. Declaramos una matriz de enteros personas[i][j]);
int edades[][]; }
//2. Instanciamos la matriz de enteros }
edades = new int[3][2];
//3. Inicializamos los valores de la matriz de enteros //1. Matriz de tipo String, notacion simplificada
edades[0][0] = 30; String nombres[][] = {{"Teresa", "Cesar", "William"},{"Yesenia", "Esteban",
edades[0][1] = 15; "Maria"}};
edades[1][0] = 20; System.out.println("");
edades[1][1] = 45; System.out.println("largo matriz renglones:" + nombres.length);
edades[2][0] = 5; //Seleccionando cualquier renglon valido nos regresa el no. de columnas
edades[2][1] = 38; System.out.println("largo matriz columnas:" + nombres[0].length);
//Imprimimos los valores a la salida estandar //Imprimimos los valores a la salida estandar
//4. leemos los valores de cada elemento de la matriz //2. Iteramos la matriz de String con un for anidado
System.out.println("Matriz enteros indice 0-0: " + edades[0][0]); System.out.println("");
System.out.println("Matriz enteros indice 0-1: " + edades[0][1]); for (int i = 0; i < nombres.length; i++) {
System.out.println("Matriz enteros indice 1-0: " + edades[1][0]); for(int j= 0; j < nombres[i].length; j++){
System.out.println("Matriz enteros indice 1-1: " + edades[1][1]); System.out.println("Matriz String indice : " + i + "-"+ j + ": " +
System.out.println("Matriz enteros indice 2-0: " + edades[2][0]); nombres[i][j]);
System.out.println("Matriz enteros indice 2-1: " + edades[2][1]); }
}
//1. Declaramos e instanciamos una matriz de personas }
Persona personas[][] = new Persona[3][2]; }
//2. Inicializamos los valores de la matriz de personas
personas[0][0] = new Persona("Juan");
personas[0][1] = new Persona("Armando");
personas[1][0] = new Persona("Karla");
personas[1][1] = new Persona("Laura");
personas[2][0] = new Persona("Pedro");
personas[2][1] = new Persona("Javier");

• Modificar y agregar más valores a las matrices y probar con

estos nuevos valores.

Matrices en Java.
• Hemos visto como declarar, instanciar, inicializar, asignar y

leer datos de una matriz.
• Además vimos cómo iterar por medio de un ciclo for anidado

los elementos de una matriz. Con esto concluimos el tema de
matrices.


lección.
Vamos a estudiar el tema de diseño de Clases en Java.
En Java normalmente crearemos más de una clase con el objetivo de crear sistemas funcionales, por ejemplo algún
sistema que procese ventas en alguna tienda o por internet, o un sistema de facturación, contabilidad, o cualquier
sistema de propósito general. Cuando creemos clases que se interrelacionen lo conoceremos como el diseño de
clases.
Con Java es posible crear cualquiera de estos sistemas, ya que es un lenguaje de propósito general. De esta manera
cubrir los requerimientos solicitados por nuestros usuarios, que son las personas o entidades que utilizarán e
interactuarán con nuestro sistema. La idea de este curso es brindar las bases de la sintaxis y conceptos de Java más
fundamentales que nos permitirán ir creando y entendiendo este tipo de sistemas.
En la lámina estamos mostrando la relación entre dos clases, las cuales se encuentran en un paquete llamado:
com.gm.ventas. Las clases están relacionadas por una relación en UML (Unified Modeling Language) que se conoce
como relación de agregación. Esta relación indica que una clase Orden contiene Productos. Una orden es un ticket
de venta, el cual tiene el resumen de todos los productos que se van a vender para una orden en particular.
Por ello la clase Orden contiene los métodos de agregarProducto, calcularTotal (de la orden), y mostrarOrden, este
último método su objetivo es mostrar el Id de la orden, el monto total de la orden, así como cada uno de los
productos agregados a la orden. Para almacenar varios productos, la clase Orden tiene como atributo un arreglo de
productos, y de esta manera podremos agregar varios productos a una orden, con ayuda del método
agregarProducto.
La clase Producto contiene tres atributos: idProducto, nombre y precio del producto, por medio de estos atributos
podremos identificar fácilmente a un producto.
Finalmente tenemos la clase con la que realizaremos las pruebas de que todo función correctamente. La clase
Ventas dentro del paquete ventas, es donde crearemos los objetos Orden y Producto y utilizaremos los métodos
respectivos para probar que funciona correctamente nuestro código.

Datos de Contacto:

Con este ejercicio pondremos en práctica el concepto de diseño
de Clases en Java. Al finalizar observaremos lo siguiente:

Crearemos el ejercicio basado en el siguiente diagrama:


Creamos la clase Producto:

Archivo Producto.java:
package com.gm.ventas; public String getNombre() {
return nombre;
public class Producto { }
private int idProducto; public void setNombre(String nombre) {

private String nombre; this.nombre = nombre;
private double precio; }
private static int contadorProductos;
public double getPrecio() {
//Constructor vacío return precio;
private Producto() { }
//Asignamos el id producto único por cada objeto creado
this.idProducto = ++contadorProductos; public void setPrecio(double precio) {
} this.precio = precio;
}
//Constructor sobrecargado de dos argumentos
public Producto(String nombre, double precio) { @Override
//Llamamos al constructor vacío para asignar el idProducto public String toString() {
this(); return "Producto{" + "idProducto #" + idProducto + ",
this.nombre = nombre; nombre=" + nombre + ", precio=" + precio + '}';
this.precio = precio; }
} }

Creamos la clase Orden:

Archivo Orden.java:
package com.gm.ventas;
public class Orden { public double calcularTotal() {

double total = 0;
private final int idOrden; for (int i = 0; i < contadorProductos; i++) {
private final Producto productos[]; total += productos[i].getPrecio();
private static int contadorOrdenes; }
private int contadorProductos; return total;
private static final int maxProductos = 10; }
public Orden() { public void mostrarOrden() {

this.idOrden = ++contadorOrdenes; System.out.println("Orden #:" + idOrden);
productos = new Producto[maxProductos]; System.out.println("Total de la orden #“
} + idOrden + ": $" + calcularTotal());
System.out.println("Productos de la orden #"
public void agregarProducto(Producto producto) { + idOrden + ":");
//Si los productos agregados no superan al máximo for (int i = 0; i < contadorProductos; i++) {
// de productos, agregamos el nuevo producto System.out.println(productos[i]);
if (contadorProductos < maxProductos) { }
//Agregamos el nuevo producto al arreglo }
//e incrementamos el contador de productos }
productos[contadorProductos++] = producto;
}
else{
System.out.println("Se ha superado el máximo de
productos: " + maxProductos);
}
}
Archivo Ventas.java:
package ventas;
//Creamos una segunda orden
import com.gm.ventas.*; Orden orden2 = new Orden();
public class Ventas { //Creamos nuevos productos

Producto p4 = new Producto("Zapatos", 200);
public static void main(String[] args) { Producto p5 = new Producto("Blusa", 90);
//Creamos varios objetos Producto
Producto p1 = new Producto("Camisa",50.00); //Agregamos productos a la orden 2
Producto p2 = new Producto("Pantalon",100.00); orden2.agregarProducto(p1);
Producto p3 = new Producto("Corbata",30.00); orden2.agregarProducto(p4);
orden2.agregarProducto(p5);
//Creamos un objeto Orden orden2.agregarProducto(p3);
Orden orden1 = new Orden();
//Imprimimos la orden 2
//Agregamos los productos a la orden System.out.println("");
orden1.agregarProducto(p1); orden2.mostrarOrden();
orden1.agregarProducto(p2); }
orden1.agregarProducto(p3); }
//Imprimimos la orden
orden1.mostrarOrden();


• Crear más ordenes y productos, y probar con distintos

valores y verificar el resultado.

• Con este ejercicio hemos puesto en práctica el concepto diseño de clases
en Java, y como apoyarnos en la relación entre ellas para poder
comenzar a crear sistemas cada vez más complejos.
• Este tema es apenas el principio de lo que estudiaremos en cursos

posteriores, pero lo importante es tener las bases de Java para seguir
avanzando con pasos firmes en el aprendizaje de este fabuloso lenguaje
de programación.
• Con esta lección concluimos el curso de Fundamentos de Java y los

invitamos a seguir su especialización Java y estudio del siguiente curso:
Programación con Java. Los esperamos


lección.
Vamos a estudiar el tema de diseño de Clases en Java.
Similar al último ejercicio de Orden-Productos, ahora se solicita realizar el laboratorio final llamado MundoPC. El objetivo de este ejercicio es
crear objetos de tipo computadora.
Cada objeto computadora se compone de 3 objetos más, que son Monitor, Teclado y Ratón. Y a su vez los objetos Teclado y Ratón descienden
de la clase DispositivoEntrada, la cual abstrae varias características, las cuales heredan directamente las clases Teclado y Ratón.
Finalmente la clase Orden contiene un arreglo de computadoras como parte de sus atributos, y será la encargada de ir agregando cada
computadora al arreglo de computadoras.
La clase MundoPC será la encargada de crear los objetos respectivos para formar tanto los objetos Computadora e irlos agregando a un objeto
Orden.
En este laboratorio final se pondrán en práctica todos los temas estudiados en este curso, por lo que de ser necesario deberán repasar cada
tema con el objetivo de poder realizar este laboratorio final.
Algunos de los temas que se deberán aplicar son:
- Herencia y llamadas a constructores padre por medio de la palabra super.

- Uso de atributos estáticos, con el objetivo de tener un contador que nos proporcione id únicos para cada objeto creado, para los objetos:
Orden, Computadora, Monitor, Ratón y Teclado.
- Encapsulamiento de atributos en cada clase.
- Constructores privados llamados desde otros constructores por medio de la palabra this
- Paso de parámetros por referencia en el método agregarComputadora de la clase Orden
- Uso del método toString, y dentro de este método super.toString() para complementar la información heredada de la clase padre
- Uso de paquetes
- Uso de arreglos que almacenan tipos Object
- Entre varios temas más.
Les deseamos mucho éxito con la realización de su laboratorio final y adelante.

Datos de Contacto:


Curso PDF

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

Curso PDF

Cargado por

Copyright:

Formatos disponibles

CURSO DE FUNDAMENTOS DE JAVA

A continuación te presentamos nuestro listado de cursos:

Lógica de Programación Hibernate Framework

Sitio Web: www.globalmentoring.com.mx

Vamos a revisar el temario general del curso de Fundamentos de Java.

¿Estás listo? ¡Vamos!

Vamos a revisar el contenido general del curso de Fundamentos de Java:

A continuación te presentamos nuestro listado de cursos:

Lógica de Programación Hibernate Framework & JPA

Sitio Web: www.globalmentoring.com.mx

Hola, te saluda Ubaldo Acosta. Bienvenidos nuevamente.

Al día de hoy Java no solamente ha cumplido y superado las expectativas originales de

Ejemplos de esto son sistemas de seguridad con cámaras de video, módems,

El lenguaje Java tiene las siguientes características generales:

También instalaremos el IDE de Netbeans. IDE significa Integrated Development Enviroment o

A continuación te presentamos nuestro listado de cursos:

Lógica de Programación Hibernate Framework

Sitio Web: www.globalmentoring.com.mx

Para ello vamos a seguir varias guías en PDF.

Veamos cada una de ellas.

www.gl obal mentoring.com .mx

Instalación del JDK de Java en Windows:

Instalación del JDK de Java en Mac OS X:

www.gl obal mentoring.com .mx

• No basta con tener instalado solo el JRE (Java Runtime

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

A pesar de que los cursos utilizan Netbeans, se puede utilizar

Seguiremos la siguiente guía en PDF.

www.gl obal mentoring.com .mx

Instalación de Netbeans en Windows:

Instalación de Netbeans en Mac OS X:

www.gl obal mentoring.com .mx

• Como hemos comentado el alumno puede utilizar cualquier

• Recordemos que un IDE (Integrated Development

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

public class HolaMundo {

public static void main(String[] args) {

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

• Un IDE es una herramienta que nos ayudará a agilizar nuestra creación de

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

Si no funciona, desinstalar y volver a instalar Netbeans.

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

Vamos a estudiar el tema de variables y operadores, esto es la base para el manejo de la

¿Estás listo? Ok, ¡Vamos!

En Java, como en cualquier lenguaje de programación, para almacenar

El objetivo de declarar una variable es reservar espacio de memoria

String saludo = "Hola Mundo";

Lógica de Programación Hibernate Framework

Sitio Web: www.globalmentoring.com.mx