03 Universidad de Java Desde Cero 3

Curso de Fundamentos de Java
Hola, te saluda Ubaldo Acosta. Bienvenida o bienvenido nuevamente. Espero que estés listo para
comenzar con esta lección.
Vamos a estudiar el tema de paquetes en Java.
¿Estás listo? Ok, ¡Vamos!
© Todos los Derechos Reservados Global Mentoring Experiencia y Conocimiento para tu Vida 2
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.
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.
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:
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 Datos de Contacto:HTML5 y CSS3
Sitio Web: www.globalmentoring.com.mx

Email: informes@globalmentoring.com.mx
www.gl obal mentoring.com .mx
Crear un programa para practicar en manejo paquetes en Java.
Al finalizar deberemos observar lo siguiente:

Vamos a crear el proyecto:

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 {
public static void main(String[] args) {

Utileria.imprimir("Juan");
}
}

El resultado es como sigue:

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

Por: Ing. Ubaldo Acosta

Hola, te saluda nuevamente Ubaldo Acosta. Espero que estés listo para comenzar con esta
lección.
Vamos a estudiar el tema de la palabra final en Java.
¿Estás listo? ¡Vamos!
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.
Fundamentos de Java Hibernate Framework


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:

Archivo Persona.java:
package ejemplopalabrafinal;
public class Persona {
private String nombre;
public String getNombre() {

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

this.nombre = 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());

}
}

• Probar con el modo debug del IDE y verificar paso a paso.
• 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.

Struts Framework HTML5 y CSS3
Datos de Contacto:

El objetivo es instalar BlueJ. Al finalizar deberemos observar lo
siguiente:

Vamos a descargar bluej.org:

Seleccionamos la opción que necesitemos, según el sistema
operativo que tengamos:

Damos doble click sobre el archivo descargado. Seguimos los
pasos descritos a continuación:

Instalamos siguiendo los pasos descritos:



Iniciamos el programa:

Iniciamos el programa:

Con este ejercicio hemos instalado BlueJ
Para más información del uso de la palabra bluej.org:
http://www.bluej.org/


Poner en práctica la creación de Clases en BlueJ. Al finalizar
deberemos observar lo siguiente:

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/


CURSO DE FUNDAMENTOS DE JAVA
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:

Por el experto: Ing. Ubaldo Acosta

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


Vamos a crear la clase Persona:

( )

package com.gm.dominio.arreglos;
public Persona(String nombre) {

}

return nombre;
}

}
@Override
public String toString() {
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");

Ejecutamos el proyecto:

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

estos nuevos valores.

• Con este ejercicio hemos puesto en práctica el concepto de
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;
public Persona(String nombre) {

}

return nombre;
}

}
@Override
public String toString() {
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.
Fundamentos de Java Hibernate Framework

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:

Vamos a crear el proyecto :

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


www.globalmentoring.com.mx
CURSO DE PROGRAMACIÓN CON JAVA
Hola, te saluda Ubaldo Acosta. Bienvenidos nuevamente a este curso de Programación con Java.
En esta primera lección vamos a revisar la sintaxis básica, la cual estudiamos a detalle en el curso
anterior, esto es sólo un breve repaso para que comencemos a calentar motores. Veremos desde
la definición básica de una Clase, hasta como instanciar objetos en Java, entre ejemplos de
sintaxis más.
Así, que si estás listo, nosotros también. Comencemos de inmediato.
Esta es una breve revisión de los elementos de una clase.
En primer lugar especificamos el paquete al cual pertenece la clase. Un paquete básicamente es como una carpeta que
agrupa varias clases que tienen algo en común, normalmente se agrupan las clases por su funcionalidad.
Posteriormente, si es necesario, realizamos los import de las clases que vayamos a utilizar. Recordemos que hay import de
clases, o también import static los cuales importan atributos o métodos estáticos para ser utilizados directamente en nuestro
código .
Después indicamos el nombre de nuestra clase. Recordemos que en un archivo sólo puede declararse una clase de tipo
public, y esta debe llamarse exactamente igual que el nombre del archivo que tiene extensión .java, sin embargo pueden
existir más clases en un mismo archivo, las cuales ya no son publicas, sino solo clases definidas dentro del mismo archivo.
Seguido al nombre de la clase, definimos los atributos de la clase. El orden de los elementos no afecta a la clase, ya que si
recordamos el diagrama de dona de un objeto, podemos entender que los atributos y métodos se pueden definir en cualquier
parte dentro de la clase, pero como una buena práctica se recomienda hacerlo en el orden mostrado. Los atributos pueden ser
de cualquier tipo de dato que ya hemos estudiado previamente, además de contener varios modificadores, como los
modificadores de acceso, o static, final entre varios más que estudiaremos más adelante.
Posterior a los atributos se recomienda declarar los constructores, de igual manera el orden no afecta, pero es una buena
práctica definirlos después de los atributos de nuestra clase. Pueden existir varios constructores, tanto privados como públicos,
con varios argumentos o sin argumentos. Si no definimos un constructor, entonces el compilador en automático agrega el
constructor vacío para que se puedan crear objetos de la clase que definimos. Si se define algún constructor distinto al vacío,
entonces el compilador ya no agrega el constructor vacío a nuestra clase, y se deberá utilizar alguno de los constructores
definidos para crear un objeto de la clase definida.
Finalmente definimos los métodos de nuestra clase, pueden existir de varios tipos, como son simples métodos de tipo get o set
para las propiedades de la clase, o métodos estáticos, públicos, privados, etc. Todo depende de la funcionalidad que
necesitemos del método definido. Esto se conoce como la interfaz del método, y no tienen nada que ver con el tema de
interfaces que veremos más adelante. La interface de una clase tiene que ver con los métodos que tenemos disponibles para
ser utilizados en una clase.
Con esto a grandes rasgos tenemos un resumen de la creación de clases en Java. Recordemos que hay varios temas más,
como el concepto de herencia y más temas, pero dejemos simple la estructura básica de la clase para comenzar a estudiar
otros temas, y en su momento retomaremos cada uno de los temas estudiados en el curso anterior, así como los nuevos
temas incluidos en este curso.
Las clases, así como los métodos tiene un inicio y un fin, el símbolo que se utiliza
para marcar el inicio y el fin son las llaves { }. Esto se conoce como bloque de
código, incluso existen bloques de código anónimos que no tienen ningún
nombre, esto lo estudiaremos más adelante.
Las variables definidas dentro de estos bloques de código tienen precisamente la

duración hasta donde termina el bloque de código donde se declara.
Por ejemplo si una variable se declara dentro del método main, únicamente
existirá durante la ejecución de este método, y terminará de existir cuando este
bloque de código termine, es decir, cuando la ejecución del método main termine.
El compilador de Java ignora cualquier espacio o salgo de línea, de tal manera

que podemos utilizar precisamente esta característica para hacer y escribir un
código más legible, conforme avancemos veremos varias buenas prácticas para
escribir el código, ya que el compilador no indicará que hay un error, sino que
nosotros deberemos utilizar estas prácticas para que nuestro código sea más
legible y entendible tanto para nosotros como para el equipo de trabajo del
proyecto en cuestión.
Este es sólo un breve repaso del tema de alcance de variables estudiado en el

curso de Fundamentos de Java.
Veamos ahora el tema de convenciones. Una convención es un acuerdo, por lo que debemos entender que el compilador no
arrojará ningún error o nos indicará que hace falta corregir o cambiar algo. Por ello esto lo debemos tomar como buenas
prácticas y es finalmente el equipo de trabajo el que definirá las convenciones a utilizar en el código que creemos. Sin
embargo estas son algunas convenciones generales que les sugerimos seguir con el objetivo que su código sea más legible y
entendible tanto para nosotros como para nuestro equipo de trabajo del proyecto respectivo.
- Las clases son sustantivos, un sustantivo es básicamente el nombre que le damos a una persona o cosa. Puede existir
físicamente o ser algo abstracto, como un concepto creado. Por ello el nombre que le demos a nuestras clases serán
sustantivos, y el nombre deberá seguir algunas convenciones. La primera letra debe estar escrita en mayúsculas, y
posteriormente utilizar la notación de camello. Esta notación quiere decir que si nuestra clase utiliza dos nombres, debemos
unirlos, sin separación y cada palabra debe iniciar en mayúsculas, por ejemplo. TarjetaCredito.
- Los métodos deben ser verbos, y la primer letra debe ser escrita en minúscula, y posteriormente utilizar la notación de
camello, por ejemplo: retirarDinero(), o cambiarEstado(), etc.
- Las variables deben ser breves pero con significado sustancial, por ejemplo fecNacimiento, sin embargo es preferible no
abreviar demasiado sus nombres de tal modo que con solo leer el código podamos entender el uso de la variable definida.
Variables con una sola letra deben ser evitadas, excepto cuando sean variables que se ejecutan en un bloque de código
pequeño y de manera temporal, como puede ser un ciclo for al definir la variable i que sirve de contador para la iteración de
este ciclo.
- Las constantes, que son las variables definidas con la palabra final, deben estar escritas en mayúsculas y si se utiliza más de
una palabra cada palabra debe estar separada por un guio bajo.
- La identación significa el uso de espacios en blanco o saltos de línea con el objetivo de hacer nuestro código más sencillo de
leer y por consiguiente más sencillo de hacer modificaciones. Por ello los métodos se identarán según la lámina descrita, es
decir, se abre la llave del bloque de código al terminar el método, y al finalizar la última línea del método se agregará en la
línea siguiente el cierre de la llave del método respectivo.
Para más información de las convenciones en Java, se creó un documento, el cual puede ver en el siguiente link:
http://icursos.net/cursos/ProgramacionJava/Leccion02/doc/convencionesJava.pdf
A continuación te presentamos nuestro listado de cursos:

Datos de Contacto:

Curso de Programación con Java
Vamos a estudiar el tema cómo documentar un programa en Java utilizando JavaDoc.
Java permite documentar nuestras clases por medio de JavaDoc, el cual es un documento HTML que muestra la
documentación de cada una de las clases de un proyecto Java.
Podemos observar que a diferencia de los comentarios normales de Java, para que nuestros comentarios sean un comentario
que sea incluido en el documento HTML generado, es necesario que los comentarios tengan la forma:
/**
* Comentario JavaDoc
*/
Y de esta manera se pueda ir documentando ya sea la clase (antes de la declaración de la misma), un atributo, un constructor
o un método.
En la lámina se muestran varios ejemplos de cómo documentar cada una de las secciones de nuestra clase.
Podemos observar también que se pueden utilizar algunos elementos para indicar algunas características más de la
documentación, como @autor, @version, @return, o más. En la siguiente lámina veremos estos elementos.
En la tabla mostrada podemos observar los elementos que se pueden utilizar al momento de
documentar nuestras clases.
Cada uno de los elementos descritos tiene una breve descripción para que tengamos
conocimiento de qué significa y en el ejercicio de esta lección veremos algunos ejemplos del uso
de varios de estos elementos.


Crear un programa para practicar en manejo de JavaDoc en
Vamos a crear el proyecto EjemploJavaDoc:
( )
( )
Vamos a crear una nueva clase:
( )
Vamos a crear una nueva clase:
Archivo Aritmetica.java: Dar click para ir
package com.gm.javadoc;
/**
* Esta clase permite realizar operaciones de aritmetica como sumar, restar, etc
al código
*
* @author: Ubaldo Acosta
* @version: 1.0
*/
public class Aritmetica {
/**
* Primer Operando
*/
int operandoA;
/**
* Segundo operando
*/
int operandoB;
/**
* Constructor de la clase
* @param a Recibe el valor para el operando A
* @param b Reciboe el valor para el operando B
*/
public Aritmetica(int a, int b) {
this.operandoA = a;
this.operandoB = b;
}
/**
* Este metodo realiza la suma de dos operandos enteros
* @return int resultado de la suma
*/
public int sumar(){
return operandoA + operandoB;
}
}
Archivo EjemploJavaDoc: Dar click para ir
/*
* Derechos reservados GlobalMentoring.com.mx
*/
al código
package ejemplojavadoc;
import com.gm.javadoc.Aritmetica;
/**
* Clase para probar el concepto de JavaDoc
* @author Ubaldo Acosta
* @version 1.0
*/
public class EjemploJavaDoc {
/**
* Metodo que ejecuta la prueba de la clase Aritmetica
* @param args argumentos de la linea de comandos
*/
int resultado = new Aritmetica(3, 2).sumar();
System.out.println("resultado:" + resultado);
}
}
Ejecutamos nuestro proyecto. Damos click derecho -> Run:
( )
• Con este ejercicio hemos puesto en práctica en concepto de
JavaDoc.
• Hemos visto que se utiliza para documentar nuestras clases,

y a diferencia de un comentario común como son // o /* */, el
comentario de JavaDoc es /** */ y este comentario se agrega
a la documentación en HTML generada para el proyecto en
cuestión.
lección..
Vamos a estudiar el tema argumentos variables en Java.
Ya hemos visto el tema de parámetros, pero ¿Qué pasa cuando queremos pasar varios parámetros del
mismo tipo a una función?. Una forma sería pasarlos como un arreglo, sin embargo, como sabemos para
ello necesitamos conocer el numero de elementos que tendrá dicho arreglo.
Una forma de lograr enviar parámetros de una manera sencilla e indirectamente crear este arreglo de
parámetros, es utilizando el concepto de varargs, que básicamente son argumentos variables.
Existen varias reglas para usar varargs, una de ellas es que los elementos que se envían, al convertirse al
final en un arreglo, deben ser del mismo tipo.
Además, para indicar que se trata de un argumento variable se debe agregar tres puntos (…) después del
tipo de datos que va a recibir el argumento.
Como se observa en la lámina hemos creado una función llamad imprimirNumeros, la cual recibe un
argumento llamado números, y para definir que es un tipo de argumentos variables hemos agregado los
tres puntos después del tipo de dato.
Posteriormente desde el método main, lo que hemos hecho es mandar a llamar este método indicando un
número de parámetros de tipo entero, pero sin preocuparnos por el número de elementos que estamos
enviando al método imprimirNumeros. Esta es precisamente la característica de varargs, la cual crear un
arreglo con el largo de elementos al recibir todos los elementos enviados al método.
Una vez que el método imprimirNumeros recibe todos los elementos, crear un arreglo del tipo indicado, y
ya podemos recorrer cada uno de los elementos tal como sabemos que debemos recorrer un arreglo de
una dimensión.
En la lámina anterior hemos utilizado un ciclo for para iterar cada uno de los elementos del
arreglo vararg, sin embargo existe una notación simplificada del ciclo for llamada forEach, la cual
podemos utilizar para iterar arreglos o colecciones, las cuales estudiaremos más adelante.
Sin embargo queremos mostrarles como simplificar la iteración de los elementos de un arreglo
utilizando el concepto de forEach. Básicamente lo que hacemos es declarar un ciclo for, pero a
diferencia de un ciclo for normal, el cual tiene 3 elementos a declarar, un ciclo forEach, solo tiene
dos elementos a declarar, que es la variable que va a recibir cada uno de los elementos del
arreglo, y el arreglo que se va a iterar.
Java internamente se encargará de hacer la iteración respectiva y dentro del bloque forEach lo
que usaremos es la variable que contendrá cada uno de los elementos del arreglo por cada
iteración.
La única desventaja es que si necesitamos conocer el índice del elemento que se está iterando de
este ciclo for, esta sintaxis no nos servirá, ya que en ningún momento se ha declarado un
contador que nos ayude a saber cual es el elemento que se está iterando, ya que el ciclo forEach
únicamente nos regresa el elemento iterado, pero no el índice que se está iterando.
Ese sería el único inconveniente a tener en cuenta, por lo demás vemos claramente cómo la
sintaxis es más limpia y menos propensa a errores, ya que no necesitamos declarar varios
elementos para iterar un arreglo, por lo que es más simple y más seguro utilizar esta notación
para recorrer los elementos de un arreglo.
En esta lámina básicamente explicaremos un regla más del uso de varargs, la cual
indica que si vamos a utilizar el concepto de varargs, es necesario que sea el último
de los argumentos declarados, de esta manera al manda a llamar la función, no
habrá confusión para el compilador, por que en cuanto detecte que comienza el
tipo de datos del tipo vararg definido, es que comenzará a crear el arreglo de
elementos enviados a la función.
En pocas palabras el compilador de Java detecta el número de elementos enviados

y una vez que ha terminado de asignar los elementos que no son vararg, revisará si
el último argumento declarado es de tipo vararg, y así es como todos los valores
restantes que sean del mismo tipo que el argumento vararg definido, los asignará a
este elemento vargarg y como sabemos finalmente los convierte en un arreglo.
Esta regla es muy importante para el uso de vararg, ya que en ocasiones lo

queremos combinar con varios argumentos, y es donde debemos respetar esta
regla.
A continuación vamos a crear un ejercicio para practicar cada uno de estos

ejemplos.

Datos de Contacto:

Crear un programa para poner en práctica el uso de
argumentos variables en Java (varargs). Al finalizar deberemos
observar lo siguiente:


Archivo EjemploVarArgs:
package ejemplovarargs;
public static void imprimirNumerosForEach(int... numeros){
public class EjemploVarArgs { //Usamos un forEach en lugar de un for normal
for(int numero : numeros){
public static void main(String[] args) { System.out.println("El numero es:" + numero );
//Imprimimos varios números }
imprimirNumeros(15,20,3,61,75,18,10); }
System.out.println(""); public static void variosParametros(String nombre, boolean

imprimirNumerosForEach(15,20,3,61,75,18,10); valido, int... numeros){
System.out.println(""); System.out.println("Nombre: " + nombre);

variosParametros("Juan", true, 15,20,14);
} System.out.println("Valido: " + valido);
public static void imprimirNumeros(int... numeros){ //Usamos un forEach

//Recorremos cada elemento for(int numero : numeros){
int elemento; System.out.println("El numero es:" + numero );
for(int i=0; i < numeros.length; i++){ }
elemento = numeros[i]; }
System.out.println("Elemento " + i + ": " + elemento); }
}
}

Ejecutamos nuestro proyecto. Damos click derecho -> Run:

( )

• Probar con distintos valores y verificar el resultado.

argumentos variables (varargs) en Java.
• Hemos visto que además del uso de argumentos variables,

podemos combinarlo con el concepto de forEach para
recorrer cada uno de los argumentos del arreglo vararg
creado.


Vamos a estudiar el tema de enumeraciones en Java.
Los tipos enumerados son un tipo especial de clase, el cual nos permite
asociar una serie de valores de tipo final, es decir que son constantes. Por
ejemplo podemos observar el la lámina las constantes de los días de la
semana.
Vemos que es como crear una clase de Java, solo que en lugar de la
palabra class, utilizamos la palabra reservada enum.
Debido a que los elementos de una enumeración son constantes, se

escriben con mayúsculas, como hemos comentado que es una buena
práctica cuando usamos constantes en Java.
Asi que podemos utilizar una clase de tipo enumeración cada vez que
necesitemos declarar una serie de valores constantes y que conozcamos
previamente, como los días de la semana, los puntos cardinales, el
conjunto de planetas, continentes, y en si cualquier conjunto de datos
que son constantes.
Una vez que hemos definido nuestro tipo enumeración podemos utilizarlo como se
ve en la lámina.
Lo que hacemos es indicar el nombre de la enumeración, en este caso Dias, y

posteriormente utilizamos alguno de los valores constantes de la enumeración, por
ejemplo: Dias.LUNES, con eso estaremos utilizando alguno de los valores de
enumeración según necesitemos.
Sin embargo no es su único uso, podemos utilizar una enumeración para comprobar
algunos de los casos de una estructura switch, la cual sabemos que seleccionará
alguno de los casos según coincida con la entrada de la sentencia switch.
Para probar alguno de los casos de la estructura switch, debemos proporcionar ya

un valor de la enumeración, como puede ser Dias.LUNES o Dias.MARTES, etc.
Y dentro del switch en cada uno de los casos podemos especificar los valores ya sin
especificar el nombre de la enumeración, sino simplemente indicando la constante
de la enumeración, por ejemplo case LUNES, o case MARTES, etc.
Este es sólo un ejemplo de cómo podemos utilizar las enumeraciones.
Sin embargo el tipo enumeración es más complejo que eso. Podemos además de definir simples valores
constantes, valores a cada una de las constantes.
Para ello debemos crear un constructor para inicializar cada uno de los valores asociado a cada constante.
Por ejemplo en el código podemos observar que estamos creando una enumeración de los continentes
existentes, sin embargo nos interesaría indicar el número de países existentes por cada continente.
Para ello cuando definimos cada constante de la enumeración, podemos proporcionar los valores que
deseemos separados por comas, en este caso es sólo un valor entero el que estamos proporcionado, el
cual significa el número de países por cada continente que declaramos.
Sin embargo para poder crear este tipo de enumeraciones más complejas, necesitamos crear un
constructor para poder crear cada uno de los elementos de la enumeración, y además los atributos que se
asociarán con los valores proporcionados por cada constante de la enumeración.
Por ello vemos en el código, que no basta con crear las constantes de la enumeración, sino que debemos
además declarar el atributo países de tipo entero, y posteriormente declaramos un constructor, el cual se
llamará de manera automática por cada uno de los elementos de la enumeración.
Y finalmente, debido a que cada uno de los elementos de la enumeración contiene definido el numero de
países, es posible declarar un método getPaises para recuperar precisamente el atributo países declarado
en el tipo enumeración.
A continuación vamos a ver cómo utilizar una enumeración de este tipo.
Como podemos observar, el uso básico es de las constantes de una enumeración es

el mismo que hemos estudiado, por ejemplo, para acceder a alguna de las
constantes especificamos el nombre de la enumeración seguido del nombre de la
constante, por ejemplo: Continentes.AMERICA, y si deseamos acceder a los
atributos de cada constante definida, podemos llamar el método para recuperar el
atributo de cada constante, por ejemplo: Contienentes.AMERICA.getPaises()
Con esto podemos observar que el uso del tipo enumeraciones puede ser más
completo que simplemente asociar algunas constantes, sino que también podemos
definir atributos y por tanto agregar métodos para recuperar los atributos para cada
una de las constantes definidas de una enumeración.
El método values se agrega por default cada que creamos una enumeración. El
objetivo de este método es que nos regrese una lista de cada una de las constantes
definidas en una enumeración.
En el código podemos ver en el método imprimirContinentes, el uso de este

método, apoyados de un ciclo forEach, lo que hacemos es definir una variable de
tipo enumeración que estas utilizando, en este caso Continentes c, y
posteriormente indicamos los valores de la enumeración llamando precisamente al
método Continentes.values().
Una vez que estamos iterando cada uno de los elementos, tenemos la variable c
para recuperar el atributo de la constante que estamos iterando, por ello podemos
pedir el método c.getPaises para recuperar el número de países del continente
seleccionado y si queremos imprimir el continente que estamos iterando
simplemente usamos la variable c definida en el ciclo forEach.
A continuación veamos un ejemplo del uso de enumeraciones.

Datos de Contacto:

Crear un programa para practicar el uso de enumeraciones en
Agregamos una clase al proyecto:
Archivo Dias.java:
package ejemploenumeraciones;
public enum Dias {
//Son valores constantes, por eso van en mayusculas

LUNES,
MARTES,
MIERCOLES,
JUEVES,
VIERNES,
SABADO,
DOMINGO
}
Agregamos una clase al proyecto:
Archivo Continentes.java:
package ejemploenumeraciones;
public enum Continentes {
AFRICA(53),
EUROPA(46),
ASIA(44),
AMERICA(34),
OCEANIA(14);
//Atributo de cada elemento de una enumeracion

private final int paises;
//Constructor de cada elemento de la enumeracion

Continentes(int paises) {
this.paises = paises;
}
public int getPaises() {

return paises;
}
} www.globalmentoring.com.mx
Archivo EjemploEnumeraciones.java:
package ejemploenumeraciones; public static void indicarDia(Dias dias) {
switch (dias) {
public class EjemploEnumeraciones { //Podemos usar algun valor constante de la
//enumeracion directamente
public static void main(String[] args) { case LUNES:
System.out.println("Primer dia de la semana");
//Valores de la enumeracion break;
System.out.println("Valor 1:" + Dias.LUNES); case MARTES:
System.out.println(“Segundo dia de la semana");
//Hacemos un test del dia utiliado break;
indicarDia(Dias.VIERNES); default:
System.out.println("Y asi seguimos con los demas dias");
//Utilizamos la enumeracion de paises }
System.out.println("Continente no. 4: " + Continentes.AMERICA); }
System.out.println("Paises en America: " +
Continentes.AMERICA.getPaises()); public static void indicarPaises(Continentes continentes) {
//Hacemos el test del numero de paises por continente switch (continentes) {

System.out.println(""); //Podemos usar algun valor constante
indicarPaises(Continentes.AFRICA); //de la enumeracion directamente
case AFRICA:
//Imprimimos los continentes System.out.println("No. Paises en:"
System.out.println(""); + continentes + ": " + continentes.getPaises());
imprimirContinentes(); break;
} default:
System.out.println("Y asi seguimos con los demás
contienentes");
}
}
public static void imprimirContinentes(){

//Utilizamos un forEach
for(Continentes c: Continentes.values()){
System.out.println("Continente:" + c + " contiene "
+ c.getPaises() + " paises.");
}
}
}
Hemos visto el uso de los tipos enumerados, así como algunas
de sus aplicaciones en nuestros código Java.
Para más información de los tipos enumerados, revisar:
https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
lección..
Vamos a estudiar el tema de bloques de código en Java.
Un bloque de código en Java básicamente es cualquier parte de código que inicia con llaves y termina con
llaves { }.
Cualquier contenido dentro de estas llaves se conoce como un bloque de código. Sin embargo, existen
bloques de código anónimo, y a diferencia de los bloques que hemos utilizado por ejemplo para crear una
clase o un método, los bloques anónimos nos permiten comúnmente inicializar variables de la clase. Estos
bloques llamados inicializadores pueden iniciar dos tipos de variables, ya sea de instancia o de tipo static.
Para declarar un bloque de tipo anónimo e inicializar variables de instancia podemos ver el ejemplo en el
código mostrado.
Podemos observar cómo de las líneas 4 a 7 se ha declarado un bloque de inicialización anónimo, cuyo
objetivo es que este código se ejecute antes de la ejecución de nuestro constructor, de hecho este bloque
de código se copia a cada constructor y se ejecuta antes de la ejecución de cada constructor.
Por ello en la salida de código (output), pordemos observar que primero se ve en consola el mensaje
“Ejecuta bloque inicializador” y posteriormente se observar el mensaje “Ejecuta Constructor”. Y vemos
también que se ha asignado correctamente el valor del idPersona con ayuda de la variable estática
contadorPersonas.
Recordemos que en primer lugar se crean las variables estáticas, y posteriormente las variables dinámicas
o atributos de clase, es por ello que en la línea 6 es posible utilizar la variable estática.
Con esto hemos visto cómo utilizar un bloque de código anónimo, el cual utilizamos para inicializar algunos
elementos de nuestras clases. Este tipo bloques de código los veremos en algunas ocasiones en los clases
Java, y ya podemos entender cómo funciona este tipo de bloques de código.
Ahora veremos cómo inicializar las variables estáticas de nuestro código por medio de un bloque
de código anónimo y estático.
Similar a como vimos en la lámina anterior, es posible utilizar un bloque de código anónimo para
realizar tareas de inicialización de variables estáticas. Para ello declaramos un bloque de código
con la única diferencia que debemos anteponer la palabra static y posteriormente abrir y cerrar
las llaves { }.
Dentro de este bloque de código podemos agregar código estático, es decir, variables estáticas.
Como observamos en el código observamos que podemos cambiar el valor de la variable estática
contadorPersonas (línea 7), ya que no siempre tendremos disponible el valor que deseamos
asignar al momento de declarar nuestras variables, y en este tipo de bloques de código es que
podemos agregar una lógica más compleja para inicializar nuestras variables estáticas en Java.
Y aquí podemos observar y concluir lo mismo que estudiamos en la lección de contexto estático.
Podemos ver en la salida (output) que primero se ejecuta el bloque estático, y posteriormente los
bloques no estáticos, es decir el bloque inicializador y finalmente el constructor de la clase.
Con esto podemos entender cómo se van combinando los bloques de código para ir inicializando
y construyendo nuestras clases Java, desde variables, bloques de código de inicialización y
constructores. Con esto ya tenemos un mayor entendimiento de la construcción de nuestras
clases.
Vamos a ver un ejemplo del uso de bloques de código.
Programación con Java Hibernate Framework


Crear un ejercicio del uso de bloques de código. Al finalizar

Vamos a crear el proyecto :

Vamos a crear una clase:

package bloquescodigo;
private final int idPersona;
private static int contadorPersonas;
//Bloque de inicialización estático

static {
//Iniciamos el idPersonas desde el valor 10
contadorPersonas=10;
//Aqui no se pueden usar variables no estáticas
//idPersona = 1;
System.out.println("Ejecuta bloque estático");
}
//Bloque de código para inicializar atributos de la clase

//El bloque se copia a cada constructor de la clase
{
System.out.println("Ejecuta bloque incializador");
idPersona = ++contadorPersonas;
}
Persona() {
System.out.println("Ejecuta Constructor");
}
public int getIdPersona() {

return idPersona;
}
}
Archivo BloquesCodigo.java:
package bloquescodigo;
public class BloquesCodigo {
Persona p1 = new Persona();

int id = p1.getIdPersona();
System.out.println("id Persona:" + id);
}


• Pueden probar agregando más bloques de código y verificar

el orden en que se ejecutan.

bloques de código, hemos visto como usarlos para inicializar
variables, tanto estáticas como no estáticas.
• Estos bloques nos servirán para inicializar variables que

pueden necesitar de procesos más complejos para asignar el
valor, o simplemente no tengamos disponible aún el valor
para asignar a la variable. Para más información pueden ver:
• https://docs.oracle.com/javase/tutorial/java/javaOO/initial.html


Hola, te saluda Ubaldo Acosta. Bienvenidos nuevamente a este curso de Programación con Java.
En esta lección vamos a revisar el tema de forEach en Java.
Comencemos de inmediato.
Además del ciclo for que ya conocemos, en el cual se debe indicar el número
de elementos a iterar, así como tener control de un contador, es posible
utilizar un ciclo for conocido como ciclo for extendido o for each. Esta es una
sintaxis resumida para iterar los elementos de un arreglo o colección de
datos.
Este ciclo for each permite iterar más fácilmente los elementos de un arreglo
o colección ya que evita errores al evitar la declaración de contadores para
recorrer el arreglo. Con este ciclo podemos iterar arreglos de cualquier tipo
de datos, ya sean tipos primitivos o tipo Object.
La sintaxis que se utiliza es muy simple, solo debemos especificar una variable
del tipo de dato del arreglo, la cual es utilizará para ir almacenando uno a uno
los elementos del arreglo o colección, y por otro lado proporcionamos el
nombre del arreglo o colección que deseamos iterar. Con ello ya podremos
acceder directamente uno a uno los elementos del arreglo o colección.
En este código podemos observar que es posible trabajar también con tipos
object, como por ejemplo, el tipo Persona con el que ya hemos trabajado
anteriormente.
La sintaxis es la misma, y sólo debemos indicar de nueva cuenta, la variable

que almacenará uno a uno los elementos del arreglo según su tipo de dato, y
una vez que hemos tenemos acceso a este tipo, entonces podemos acceder a
los atributos o métodos del tipo que hayamos declarado, por ejemplo,
persona.getNombre();
La sitaxis for each es recomendable cuando queremos recorrer los elementos

de un arreglo o colección en su totalidad, pero si deseamos tener un control
más preciso y por ejemplo detener la ejecución del ciclo una vez encontrado
algún elemento, o haber llegado a cierto índice, entonces es recomendable
utilizar un ciclo for normal, o incluso while o do-while dependiendo del caso,
ya que con todos estos ciclos tenemos acceso al índice y sabemos en todo
momento el valor de índice que se está recorriendo. Esto nos permite tomar
decisiones al momento de recorrer cada uno de los elementos, y esto no
sucede en el ciclo for each ya que no tenemos control de ningún contador o
índice al recorrer los elementos.
A continuación vamos a ver un ejemplo de esta sintaxis.

A continuación te presentamos nuestro listado de cursos:

Datos de Contacto:


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



package foreach;

private final int idPersona;
private static int contadorPersonas;
Persona(String nombre){
idPersona = ++contadorPersonas;
}

return nombre;
}

}
}
Archivo ForEach.java:
package foreach;
public class ForEach {
//Creamos un arreglo de Personas

Persona[] personas = {new Persona("Juan"), new Persona("Karla")};
//Iteramos cada elemento del arreglo de personas

for (Persona p : personas) {
//Accedemos a las propiedades y/o metodos del objeto
String nombre = p.getNombre();
System.out.println("Nombre persona:" + nombre);
}
System.out.println("");
//Creamos un arreglo de enteros
int[] edades = {15, 20, 41, 50};
//Iteramos el arreglo
for(int edad : edades){
System.out.println("Edad:" + edad);
}
}
}


• Se pueden crear más arreglos y probar la ejecución del ciclo

for each.

Con este ejercicio hemos puesto en práctica el ciclo for each.
También hemos comentado que no es siempre conveniente
utilizar este ciclo, pero si deseamos recorrer por completo el
arreglo o la colección de datos entonces si es factible utilizar y
aprovechar la sintaxis simplificada del ciclo for each.


03 Universidad de Java Desde Cero 3

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

03 Universidad de Java Desde Cero 3

Cargado por

Copyright:

Formatos disponibles

Curso de Fundamentos de Java

Vamos a estudiar el tema de paquetes en Java.

¿Estás listo? Ok, ¡Vamos!

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.

Sin embargo podemos observar en la lámina un ejemplo del dominio

En Java es posible importar los métodos estáticos a utilizar, de esta manera

En el ejemplo mostrado podemos observar que la clase Utileria y el paquete al que

En la tabla mostrada, podemos observar algunos de los paquetes Java más

Lógica de Programación Hibernate Framework

Sitio Web: www.globalmentoring.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 Utileria {

www.gl obal mentoring.com .mx

public class EjemploPaquetes {

public static void main(String[] args) {

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

//Importamos el metodo estatico a utilizar

public class EjemploPaquetes {

public static void main(String[] args) {

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

• Para más información de los paquetes en Java:

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

Vamos a estudiar el tema de la palabra final en Java.

¿Estás listo? ¡Vamos!

Fundamentos de Java Hibernate Framework

Sitio Web: www.globalmentoring.com.mx

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

public class Persona {

private String nombre;

public String getNombre() {

public void setNombre(String nombre) {

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

//Clase marcada como final

//Variables marcadas como finales

public static final Persona persona = new Persona();

//Metodo final, estudiaremos el tema de sobreescritura en otra leccion

//Marca error: No se puede heredad de una clase final

public class EjemploPalabraFinal {

public static void main(String[] args) {

//No es posible cambiar la refEjeerencia de la variable persona

System.out.println("Nombre persona:" + ClaseFinal.persona.getNombre());

//Pero si es posible cambiar el estado del objeto

System.out.println("Nombre persona:" + ClaseFinal.persona.getNombre());

www.gl obal mentoring.com .mx

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

www.gl obal mentoring.com .mx

• Hemos visto que es posible utilizar la palabra final en 3

www.gl obal mentoring.com .mx

www.gl obal mentoring.com .mx

Vamos a estudiar el tema de BlueJ y Java.

¿Estás listo? Ok, ¡Vamos!