Aprende Java

Aprende a programar desde cero en Java.
Curso
paso a paso
Si has ingresado en esta sección, es para saber alguna de las siguientes cosas: ¿Cómo
programar en Java?, ¿Qué diferencia a Java de algunos otros lenguajes de
programación?, ¿Por qué programar en Java? y algunas cosas más.
En esta sección responderemos estas preguntas y aprenderemos en qué consiste

programar en Java y sus conceptos principales, los cuales iremos desarrollando en
éste articulo y a lo largo de todo el curso de Java del sitio, así que comencemos.
Java es un lenguaje 100% orientado a objetos de alto nivel, para programar en Java,
así sea la aplicación más básica siempre necesitaremos como mínimo una clase con el
método principal (main). Dado que Java es un lenguaje de alto nivel, hay muchos
conceptos que se facilitan en comparación a otros lenguajes de programación, el
ejemplo más claro es el manejo de punteros y gestión de memoria, los cuales son
bastante fáciles en Java (es algo prácticamente automático) mientras que en C y C++
es un poco más complicado; sin embargo no todo es bueno, pues su velocidad
disminuye al necesitar de un mayor número de instrucciones y el programador no
tiene control sobre algunas cosas pero no te preocupes por esto, Java es un lenguaje
bastante usado, extendido y poderoso. Actualmente programar en Java es bastante
sencillo e intuitivo con la correcta documentación y dedicación. Comencemos:
La última actualización de este artículo fue hace 1 año
Instalación y configuración de Java y un entorno de

desarrollo IDE) para Java
Cabe mencionar desde un comienzo, que existe una enorme cantidad de editores
(IDE), entornos de desarrollo, etc. para Java, sin embargo para una mayoría de
programadores experimentados son solo algunos los más populares, cómodos,
potentes y sencillos, a continuación haré una corta lista de los entornos de desarrollo
que alguna vez he utilizado y que me perecen fáciles de instalar, comprender,
1
configurar y manejar. Cualquiera que sea el editor (IDE) de Java que elijas, no debe
presentarte problema alguno para desarrollar tus aplicaciones. En mi punto de vista
personal, el entorno de desarrollo para Java más potente es Netbeans, aclaro que es
un mero punto de vista personal y reconozco también que entornos para Java como
Eclipse presentan varias ventajas con respecto a Netbeans, pero bueno, nada es
perfecto y hace parte de nuestras competencias, sabernos defender con uno o con el
otro, tu simplemente para aprender acomódate con el que más te llame la atención.
Nota: Al final de la descripción de cada uno de los editores o entornos de desarrollo

(IDE) para Java, incluiré un enlace a la web del autor donde podrás descargarlo y
probarlo.
Desde lo personal, como mencioné hace un momento, actualmente utilizo Netbeans.

Se los recomiendo, porque a mi parecer facilita mucho varias cosas al momento de
programar en Java y posee una documentación y tutoriales muy completos
Veamos ahora sí, una lista de algunos de los principales editores (IDE) para Java, en
orden de utilidad (nuevamente desde mi punto de vista).
Netbeans:
NetBeans es un entorno de desarrollo integrado libre, hecho principalmente para

Java aunque actualmente ofrece también soporte para muchos otros lenguajes.
Netbeans posibilita la instalación de plugins que permiten aumentar las
características ofrecidas por éste y realizar tareas más complejas. NetBeans IDE es
libre y gratuito sin restricciones de uso.
NetBeans es un proyecto de código abierto muy popular que posee una gran base de
usuarios, una comunidad en constante crecimiento y por ende gran facilidad al
momento de solicitar ayuda. Sun MicroSystems fundó el proyecto de código abierto
NetBeans en junio de 2000, actualmente Oracle es el encargado del mantenimiento
y desarrollo de este y hasta ahora, todo va muy bien.
Nota: Netbeans ha estado en un proceso de transición de Oracle (anterior

propietario) a Apache (nuevo propietario), y el proyecto ha sufrido bastantes
cambios. Sin embargo, a partir de la versión 12.0 ya han mejorado bastante y el
proyecto debería poderse usar sin problemas, especialmente para desarrollar en Java.
Puedes Descargar la versión más reciente de Netbeans aquí.
2
IntelliJ:
IntelliJ es creado por JetBrains, uno de los creadores de entornos de desarrollo más
populares a nivel empresarial, no solo para Java, sino para otro tipo de proyectos y
lenguajes de programación. IntelliJ, posee una versión de comunidad que puedes
usar de forma completamente gratuita y abierta para tus proyectos Java.
Puedes Descargar IntelliJ para cualquier sistema operativo acá.
Eclipse:
Eclipse es un entorno de desarrollo integrado de código abierto multi-plataforma que

nos permite entre varias cosas más desarrollar aplicaciones en Java. Está también
abierto a la posibilidad de instalarle plugins para aumentar sus características y llevar
a cabo tareas más especificas y complejas. Eclipse es también altamente usado por
programadores y es de hecho una herramienta que deberías saber usar en cualquier
momento de tu vida profesional.
Nota: En el enlace que daré a continuación tendrás varias opciones para descargar,
de todas estas te recomiendo el primer enlace "Eclipse Standard", que es la versión
para Java más simple y tiene todo lo necesario.
Puedes encontrarlo aquí
JCreator:
JCreator es un entorno de desarrollo que posee una versión profesional y otra

versión libre, sin embargo la versión libre es bastante sencilla, desde el punto de vista
del aprendizaje entre menos ayudas tengas mas aprenderás por lo cual la versión
libre sería la ideal, sin embargo creo que esta versión es demasiado simple y en
realidad se trata de aprender con rapidez y facilidad de manera autónoma, sin
embargo no estaría mal tenerla como parte de nuestro repertorio.
Nota: En el enlace que daré a continuación tendrás tres opciones para descargar, de
todas estas te recomiendo la primera, que es la versión para Java más completa, sin
embargo es una versión de prueba de 30 días, pero podrías comprarla o buscar la
manera de usarla seguramente.
3
Instalación del JDK (importante)
El JDK (Java Development Kit) es el conjunto de librerías, paquetes, clases, métodos,

etc. que posee Java, de este modo, es importante tenerlo instalado para poder
desarrollar aplicaciones en Java, no pretendo profundizar mucho en este aspecto,
pues consiste en instalar la aplicación y debería ser todo, sin embargo a veces se
hace necesario configurar las variables de entorno (según el IDE seleccionado). Si
tienes problemas con esto, ponlo en la sección de comentarios más abajo y te
ayudaré de inmediato.
Nota: En el enlace que daré a continuación tendrás tres opciones para descargar, de
todas estas debes seleccionar la primera que dice "Java Platform (JDK)", que es la
que necesitamos.
Puedes encontrar el JDK aquí

Instalación de la maquina virtual (Importante)
La maquina virtual de Java, en términos sencillos, es la encargada de comprender lo

que escribes en tu programa (tu código) y hacerlo entendible para el computador, es
un intérprete de tu código Java para el computador. Es muy seguro que ya la tengas
instalada sin quizá saberlo, sin embargo por si acaso no, acá te dejo el enlace
Muy bien, ahora tienes tu herramienta de trabajo, habrás elegido la que mejor te
parezca y la tendrás instalada en tu computador. Si tienes algún problema, deja tus
problemas y comentarios en la sección de comentarios y describe tu problema.
Ahora sí!!! Por fin!! Llegó el momento de aprender a programar en Java, pues ya
tenemos lo necesario. Primero, puedes acceder a una sección opcional
llamada Creación de Proyectos en la que explico cómo crear proyectos en Netbeans,
como añadir elementos al proyecto y como ejecutarlo. En caso de que ya sepas como
crear y ejecutar proyectos en el entorno seleccionado, podemos avanzar a la sección
de Librerías en Java y Paquetes en Java recuerda que también puedes dejar un
comentario acerca de esta sección, y así ayudarás a mejorar el sitio, todas las
sugerencias y opiniones son tenidas en cuenta.
4
La última actualización de este artículo fue hace 11 meses
Creando nuestro primer proyecto Java usando

Netbeans
La mayoría de los entornos de desarrollo integrados (IDEs) para Java, hacen uso de
un concepto de proyecto. Un proyecto en un IDE cualquiera, es un "contenedor"
global donde podemos incluir o crear todos los archivos que de una u otra forma
vayan a ser utilizados en nuestro programa, clases, interfaces, archivos de texto,
imágenes, paquetes, etc.
Un proyecto en un entorno de desarrollo nos permite dar un orden y una

clasificación a nuestro trabajo y a nuestros programas, evitando así que estemos
desarrollando algo con los archivos de diferentes programas mezclados en un mismo
lugar. Los proyectos nos permiten mantener ordenado nuestro espacio de trabajo
permitiéndonos ser más ágiles y evitar errores.
Vamos a ver rápidamente los fácil que es crear un proyecto en Netbean. Veremos,
algunas imágenes y una guía para crear un proyecto en este entorno de desarrollo.
Comencemos:
¿Cómo crear y ejecutar un proyecto en Netbeans
En la mayoría de los entornos de desarrollo el proceso es bastante similar, pero aquí

explicaré los detalles relevantes de esto, para que al momento de crear un proyecto
tú mismo, sepamos qué cosas se pueden cambiar cuándo y para qué.
Como primer paso, necesitamos abrir nuestro entorno de

desarrollo, de modo que según nuestro sistema operativo,
deberíamos seguir una ruta como la siguiente. Vamos a: Inicio »
Todos los Programas » Netbeans » Netbeans IDE x.x.x. Notar que en
el momento que hagas esto puede haber una versión superior a
la indicada en la imagen, por eso he puesto x.x.x.
5
Una vez haya iniciado correctamente Netbeans, podremos crear el nuevo proyecto.
Para crear el proyecto, debemos seguir

unos pasos bastante simples. En nuestra
ventana principal en la parte superior
tenemos una serie de opciones, debemos
dar clic en: File » New Project..., tal como
muestra la imagen.
Hecho esto, se nos

mostrará una nueva
ventana donde
podremos seleccionar el
tipo de proyecto a
crear, tenemos varias
opciones, de éstas seleccionaremos Java » Java Application y damos en Next>
Luego
se abrirá
una
ventana
pidiéndonos alguna información de nuestro proyecto. Para este ejemplo, como

nombre al proyecto le pondremos Curso Aprender A Programar. La ubicación la
podemos cambiar dando clic en examinar, sin embargo, es recomendable dejarla en la
ubicación por defecto por comodidad y facilidad y finalmente damos clic en finish.
Así nuestra ventana quedaría como la imagen.
6
Hecho esto, podremos añadir elementos a nuestro proyecto, clases, interfaces, etc.
Vamos a ver cómo crear una clase al interior de nuestro proyecto:
Hacemos clic derecho sobre el proyecto,

luego en New y finalmente en Java Class...
Aparecerá una ventana

pidiendonos el nombre para la
clase y un paquete, le
pondremos MiPrimeraClase a la
clase y al paquete lo
pondremos mipaquete.
En cuanto tengamos nuestro proyecto y nuestra clase creados podremos crear

nuestro primer programa. A modo de prueba, vamos a ejecutar un Hola Mundo en
Java, de modo que podemos copiar de aquí el código y pegarlo en nuestra clase.
package mipaquete;
public class MiPrimeraClase
public static void main(String[] args)
System.out.println("Hola mundo");
7
Una vez pegado el código, podremos ejecutar
nuestro primer programa en Java
presionando Shift+F6. Al ejecutarlo se nos
mostrará en la parte inferior la ejecución de nuestro código,
Muy bien, es todo en este contenido, espero que todo haya quedado lo más claro
posible. De igual forma, te recuerdo que puedes dejar tu dudas, comentarios,
problemas y/o sugerencias en la sección de comentarios. Si todo ha ido bien y ya
dominas perfectamente y sin problemas la creación y ejecución de proyectos en
Netbeans, podremos continuar con la siguiente sección llamada Comentarios en java.
Domina los conceptos principales de Java y la POO:

Clases, Objetos, Mensajes, y Herencia en Java
Una forma infalible de comenzar a comprender y a aprender algo es viendo un
ejemplo funcional de ello. Al menos en el mundo de la programación un buen
ejemplo vale más que varios artículos hablando del tema, así que sin más preámbulo,
comencemos con un buen ejemplo de un programa en Java y sus conceptos
principales explicados paso a paso y de forma sencilla de comprender :)
Un ejemplo para programar en Java
A modo de ilustración, imaginemos que tenemos una fábrica de galletas, tenemos

diferentes tipos de galletas con diferentes formas sabores y colores. Al tener
diferentes formas necesitaremos entonces diferentes moldes para las galletas que
fabricamos, necesitaremos diferentes recetas para el sabor de cada una y por ultimo
diferentes colores o maneras de darle color a nuestras galletas. Vamos entonces a
juntar nuestra historia con los conceptos fundamentales de Java.
¿Qué son las clases en Java?
Una clase en lenguaje de programación Java se puede entender como un prototipo

que define las variables (lo que lo diferencia de otras) y los métodos (las acciones que
peude realizar) comunes a un cierto tipo de instancias.
8
En nuestro ejemplo de la fábrica de galletas, la clase sería uno de los moldes para
galletas, junto con los métodos para colorearlas y la receta (método para prepararlas).
Quiere decir que en nuestro programa de Java tendremos una manera de especificar
las caracteristicas de la galleta dado que hay diferentes moldes de galletas.
En java las clases son las matrices de las que luego se pueden crear múltiples
instancias del mismo tipo. La clase define las variables y los métodos comunes a las
instancias de ese tipo (el tipo de la clase creada), pero luego, cada instancia de esta
clase tendrá sus propios valores (sus propio molde, color y receta) y compartirán las
mismas funciones.
En java, primero deberemos crear una clase antes de poder crear instancias o
ejemplares de esa clase. Evidentemente primero necesitamos los moldes y demás
para poder hacer las galletas.
¿Qué son los objetos en Java?
En el ámbito del lenguaje de programación Java, un objeto es básicamente una

instancia de una clase (las instancias de las que hablábamos hace un momento).
Para nuestro ejemplo de la fábrica de galletas, los objetos vendrían siendo cada una
de las diferentes galletas obtenidas de los moldes definidos (clases).
Lo más importante de los objetos en Java es que permiten tener un control total
sobre "quién" o "qué" puede acceder a sus miembros, es decir, los objetos pueden
tener miembros públicos a los que podrán acceder otros objetos o miembros
privados a los que sólo puede acceder él. Estos miembros pueden ser tanto variables
como funciones.
El gran beneficio de todo esto es la encapsulación. En java el código fuente de un

objeto puede escribirse y mantenerse de forma independiente a los otros objetos
contenidos en la aplicación (mas adelante veremos esto con más detalles).
¿Qué son los mensajes en Java?
Para poder crear una aplicación Java que sea un tanto robusta, es muy probable que
necesitemos más de un objeto (más de una instancia de una clase), y probablemente
algunos de estos objetos no deben estar aislados unos de otros, pues bien, para
comunicarse, esos objetos se envían mensajes entre sí.
9
Los mensajes son simples llamadas a las funciones o métodos del objeto en particular
con el cual se quiere comunicar para solicitarle que ejecute alguna "accion" según sus
métodos y/o atributos.
En nuestro ejemplo de la fábrica de galletas, los mensajes vendrían siendo la manera

de manipular la maquina encargada de crear galletas diciéndole qué receta, colores o
que molde usar en un momento cualquiera.
¿Qué es la herencia en Java?
¿Qué significa esto de la herencia?, ¿quién hereda qué?, bueno calma, no entres en
pánico, esto sólo significa que en Java puedes crear una clase partiendo de otra que
ya exista.
Es decir, puedes crear una clase a través de una clase existente, y ésta clase tendrá
todas las variables y los métodos de su "superclase", y además se le podrán añadir
otras variables y métodos propios.
Se llama "Superclase" a aquella clase de la cual desciende una clase, más adelante
veremos un poco más de esto al detalle.
Vamos a ver un pequeño ejemplo basado en la fábrica de galletas que hemos estado
tratando a lo largo de este artículo. Vamos a crear una pequeña clase llamada
"Galleta" que contendrá los diferentes atributos.
Ejemplo de una clase en Java
public class Galleta

{
private String molde;
private String receta;
private String color;
public Galleta()
{
//Constructor
}
public Galleta fabricar_galleta()

{
10
//Método para fabricar galletas
}
}
De momento no pretendo profundizar mucho con respecto a esto. En el código

anterior están implementados algunos de los conceptos mencionados en este
artículo. Si no comprendes bien el código, no te preocupes que a lo largo de este
curso de Java iré explicando todo esto.
Muy bien, probablemente ya tienes cierta noción acerca de lo que estamos hablando
y no es necesario profundizar mucho más por ahora, recuerda que si no estás
entendiendo algo de lo que he hablado anteriormente en esta sección, no debes
preocuparte, pues más adelante iré clarificando todo con más detalle, si tienes alguna
duda o sugerencia usa la sección de comentarios que se encuentra al final de este
artículo.
¡Listo! Vamos a la siguiente sección para conocer un poco acerca de

algunos entornos de desarrollo para Java y tener una buena herramienta de trabajo
para programar en Java.
La última actualización de este artículo fue hace 2 años
Documentación de programas en Java. Uso de

comentarios en Java
Los comentarios en Java y en cualquier lenguaje de programación son una
herramienta que sirve para apoyar la documentación de los programas que
desarrollamos y así facilitar su posterior comprensión por parte de alguna otra
persona que comprenda algo de Java o el lenguaje en particular. Los comentarios,
son líneas de código, que no son tenidas en cuenta por el compilador en el momento
de ejecutar nuestra aplicación (es como si no estuviesen allí), por lo tanto no están
sujetas a restricciones de sintaxis ni nada similar y podremos escribir cualquier cosa
en éstas. El uso principal de las líneas de comentario en Java, es dar orden al código y
hacerlo más comprensible, en especial cuando serán terceros los que verán y
deberán entender nuestro programa (como dije anteriormente). Por ejemplo es muy
común usar las líneas de comentarios, para dar una breve explicación de cómo
11
funciona cierta parte de un código, lo cual permite identificar todo con mayor
rapidez.
Vamos entonces a ver cómo hacer comentarios en Java y las características de estos.
Existen tres tipos de comentarios en Java, así que veamos cada uno en detalle:
Comentarios en Java de una sola línea:
Pueden ser colocados en cualquier parte de nuestro código en Java y comienzan por
un doble slash "//", al colocar el doble slash en cualquier línea de código, todo lo que
haya de ahí en adelante en dicha línea será tomado como comentario, ten en cuenta
que el doble slash solo convierte en comentario al texto que haya justo después de
éstos y que pertenezca a su misma línea, las líneas de abajo de este, no se verán
afectadas, tal como es de esperarse, el doble slash "//", solo afecta una línea desde el
lugar donde se colocan.
Ejemplo comentarios en Java de una sola línea:
//Declaración del método principal

public static void main(String args[]) //Aquí también se puede comentar
{
// Esta línea no se ejecuta ----> for(int i = 0; i <= 0; i++)
//Aquí hay otro comentario
System.out.print("Hola"); //Esta línea mostrará Hola en pantalla
}
Comentarios en Java de múltiples líneas:
Los comentarios multi-línea en Java tal como el nombre lo indica nos permiten
comentar varias líneas de nuestro código Java de manera mucho más sencilla en vez
de esta añadiendo doble slash "//" a cada línea. Estos comentarios van cerrados
entre "/*" y "*/", es decir comienzan donde se ponga "/*" y terminan donde esté el
"*/". Estos comentarios funcionan de manera similar a los comentarios de una sola
línea, pero deben tener un comienzo y un final. A diferencia de los comentarios de
una sola línea, al poner el símbolo "/*" todo el código que haya tanto en la misma
línea, como en las línea posteriores de este se convertirán en comentarios hasta que
12
pongamos el "*/", de manera que si iniciamos un comentario de múltiples líneas,
debemos cerrarlo, tal como sucede con las llaves o los corchetes en Java.
Ejemplo de comentario en Java de múltiples líneas
// Declaración del método principal

public static void main(String args[])
{
/*
Esta línea no se ejecuta ---- for(int i = 0; i <= 0; i++)
Esto aun sigue siendo un comentario
System.out.print("Hola"); //Este es otro comentario
*/
System.out.print("Fin de comentarios");
}
Comentarios de documentación en Java (Javadoc):
Los comentarios de documentación, también conocidos como Javadoc, son de

especial utilidad al momento de documentar no sólo el código fuente, sino el
proyecto como tal. Por medio de herramientas externas, podremos generar de forma
automática la documentación de un proyecto Java, a partir de estos comentarios de
documentación o Javadocs.
Estos comentarios van cerrados entre "/**" y "*/", es decir comienzan donde se
ponga "/**" y terminan donde esté el "*/". Nótese que los comentarios de
documentación, a diferencia de los comentarios de múltiples líneas, inician con "/**"
(doble asterisco) en lugar de "/*" (un solo asterisco). Adicionalmente, se recomienda
que cada línea que compone el bloque de comentarios inicie con "*".
Estos comentarios además requieren de algunos "componentes" para indicar los

componentes del código fuente, tales como parámetros, tipos de retorno, entre
otros. Estos "componentes" se normalmente se preceden por un @, por ejemplo para
indicar un parámetro de una función de usa @param, o para indicar detalles sobre el
retorno se usa @return. Veamos un ejemplo:
13
Ejemplo de comentario de documentación en Java (Javadoc)
/**
* Este método se encarga de iniciar la ejecución del programar
* Éste es el método principal del proyecto
* @param args[] es un arreglo con los parámetros que el reciba por consola
* @return void
*/
{
String saludo = mostrarSaludo("Juan");
}
/**
* Este método se encarga mostrar un saludo al usuario
* @author JuanDMeGon
* @param nombre es una cadena de texto con el nombre a usar
* @return El mensaje usado para el saludo
*/
public static String mostrarSaludo(String nombre)
{
String mensaje = "Hola " + nombre;
System.out.print(mensaje);
return mensaje;
}
14
Muy bien, eso es todo para ésta sección, como habrás visto es bastante sencillo todo
y no debería dar problemas. De igual forma si tienes alguna pregunta y/o problema
puedes plantearlo en la sección de comentarios. Si todo ha ido bien, podremos
continuar con nuestro curso de Java y ver ahora cómo crear un programa en Java
Básico y continuar con nuestro aprendizaje.
Ejemplo simple de programación en Java. Un

programa básico para programar en Java
Toda aplicación básica de consola en Java contiene una clase principal con un
método main, al igual que en C++. El método main es lo primero que se ejecuta
cuando se inicia la aplicación desde la línea de comandos, es decir que la ejecución
del programa comienza desde allí. De esta forma podemos deducir que cualquier
llamado, declaración o método que no sea utilizado de manera directa o indirecta
desde el método main nunca se ejecutará, con lo de manera indirecta me refiero a
que no se haga directamente desde el main sino desde un método que llama a otros
el cual es llamado desde el main, así se ejecutaría de manera indirecta.
En Java el método main recibe como argumento un arreglo de String (más adelante
hablaremos sobre arreglos). Este arreglo contiene los argumentos enviados por la
línea de comandos para la invocación del programa. Generalmente en una aplicación
de Java básica, no se hace uso de éste argumento, sin embargo hay algunos casos
especificos en los que sí.
No te preocupes si te es difícil esto del argumento, más adelante te quedará más

claro, por ahora veamos algo de Java básico, algo acerca de la estructura mínima de
un programa escrito en Java.
La estructura básica de un programa desarrollado usando Java es la siguiente:
public class Nombre_Clase
15
public static void main (String args[])
//bloque de sentencias;
Muy bien, como quizá has visto en la sección de C++, ya sabrás seguramente que es
cada una de estas 5 líneas, pero como quizá no lo recuerdes o simplemente no has
pasado por esta sección, entonces veamos en detalle el código anterior.
Línea 1 del programa Java básico:
La primera línea de nuestro código ha declarado una clase llamada "nombre_clase"

(allí puedes poner el nombre que desees), la cual es pública (public), esto quiere decir
que tendrás acceso a dicha clase, desde cualquier parte del código sin ningún tipo de
complicaciones, ahora, lógicamente tú le podrás poner el nombre que te guste más.
Nuestra línea 2, tiene una llave abriendo "{", esto quiere decir que todo lo que haya
despues de esta llave forma parte de la clase "nombre_clase" (o como le hayas
llamado) e indica el comienzo de las líneas de sentencia de ésta, en este caso, esta la
declaración de la función main() que está má adelante.
La línea número tres contiene la declaración del mé main, en cualquier aplicación de

Java básica o avanzada, el método main es indispensable, éste metodo es público,
pero hay algo especial en él: el mé main es del tipo void, osea vacío (una función
puede retornar valores del tipo entero, decimal, cadena de texto, entre otros) al
poner void, estamos queriendo decir que la función main no retornará nada al
finalizar (en la teorí de la programación, dado que el "main" no retorna nada, deja de
ser una función y se convierte en un método).
Si se le pusiera por ejemplo int (entero) entonces al final de la función, ésta debería
retornar algún número o variable de tipo entero, sin embargo al hacer esto, ya no
estaríamos hablando del método principal de nuestro programa sino que serí una
16
funció creada por nosotros llamada main y que es del tipo entero, eso es ya otro
tema muy distinto llamado sobrecarga de funciones que veremos más adelante.
No te preocupes si no entiendes bien esto de retorno o no retorno, entero y eso,

pues más adelante hablaré acerca de ello a fondo. Lo realmente importante hasta
ahora es que comprendas que existe un método principal llamado main y una clase
principal pública que lo contiene y que desde este método comienza la ejecución del
programa.
La línea tres, también tiene un argumento para el método main, es lo que está dentro
de los parentesis "String args[]", esto quiere decir que la función main, debe recibir un
argumento el cual es de tipo String y es además un arreglo, luego hablaré de los tipos
de datos, no te preocupes mucho por esto. Aunque tu programa sea Java básico y no
hagas uso de éste argumento, es obligatorio declararlo o tendremos un error de
compilación, así que siempre debes ponerlo en tu código.
La línea 4 de nuestro programa básico contiene una llave abriendo que indica el inicio
del bloque de instrucciones del método main
La línea cinco contiene el bloque de sentencias del método main, es decir, las líneas
de código que nuestro programa seguirá durante su ejecución, es de notar que cada
sentencia termina con punto y coma ";". Se entiende como línea de sentencia, a las
líneas de código que en ellas contienen la declaración de alguna variable, o alguna
operación,( suma resta, división, etc.) o cualquier acción, como modificar, asignar, o
eliminar algo. Evidentemente el bloque de sentencias puede estar compuesto por
una cantidad ilimitada de instrucciones (no es una única línea). Una vez que éste
bloque de sentencias llega a su fin, también lo hará la ejecución de nuestra aplicación
Línea 6 y 7 :
Estas líneas contienen una llave cerrando "}" eso nos indica que en ésta termina la
ejecución de alguna función (para identificar esta función que se cierra, sigue la
indentación y seguramente sabrás cual es la que estamos cerrando). Pues bien, si no
te has equivocado, habrás notado que la función (mas bien método) que esta llave
está cerrando es main(), y luego está la línea 7 que cierra la definición de nuestra
clase y da por terminado el có de nuestro programa básico en Java.
17
Antes de finalizar esta sección quisiera poner un pequeño ejemplo que muestre la
estructura anteriormente explicada, asi que veamos
Ejemplo de un programa de Java básico
El programa que pondré a continuacion simplemente mostrará en pantalla la tabla del

12, algo bastante sencillo y que podrás probar tu mismo en tu casa copiando el
código. Recuerda no preocuparte mucho por comprender a la perfeccion todo el
bloque de sentencias (lo que habrá al interior del método main), pues todo esto y
varias cosas más serán explicadas con detalle luego. Ahora si veamos.
public class Mi_Clase_1
for(int i = 0; i <= 12; i++)
System.out.print("12 * "+ i + " = " + 12 * i + "\n");
Tal como mencioné anteriormente, este programa

de Java básico va a mostrar en pantalla una serie
de resultados de multiplicar al 12 desde 12*0
hasta 12*12, es de notar que su cambias el límite
del ciclo for por cualquier otro número, entonces
el programa multiplicará hasta terminas, quizá si
eres curioso o curiosa pruebes en cambiar el 12
por un cien o por un mil, y verás cómo funciona,
en todo caso, si ejecutas este código en Netbeans,
18
eclipse, o cualquier otro IDE para Java, deberías obtener algo como lo que se ve en la
imagen.
Deberías intentar cambiar el código, mover algún número, cambiar nombres, valores
y todo lo que se te ocurra en él, te aseguro que en el proceso aprenderás unas
cuantas cosas valiosas que te van a facilitar el proceso de aprendizaje y mejorarán
tus conocimientos, recuerda que la única forma de aprender a programar es
programando, así que.... ¿Qué esperas?, recuerda que si tienes problemas o dudas
durante el proceso, la sección de comentarios está allí para ayudarte.
Muy bien, ahora ya conoces un poco sobre la estructura básica de un programa en

Java, vamos a seguir con otras generalidades que nos serán muy útiles durante el
resto del curso y en el momento de crear nuestras propias aplicaciones. Recuerda
que si tienes algún tipo de duda, comentario, problema o sugerencia puedes
hacérmelo saber sin ninguna preocupación en la sección de comentarios más abajo.
Para continuar con el curso, es momento de dirigirse a la sección de Paquetes en
Java, nos leemos allí.
Objetos, clases y constructores en Java. Crear una

clase y un objeto. Class y new en Java
Cuando comenzamos con este curso de Java, hice una introducción en la cual
expliqué los principales conceptos de la programación orientada a objetos y en
específico en el lenguaje Java. Vimos la definición y algún ejemplo sobre clases en
Java y también vimos qué son y para qué son útiles los objetos en Java.
Voy a retomar parte de las definiciones y el ejemplo que usé en la introducción para
profundizar aquí sobre las clases y los objetos en Java, los constructores y los
métodos y algunas otras cosas particulares de estos.
Un ejemplo para clases y objetos en Java
Vamos a imaginar que somos los dueños o administradores de una fábrica de

galletas, vendemos diferentes tipos de galletas con diferentes formas, sabores y
19
colores, evidentemente al tener diferentes formas para nuestras galletas
necesitaremos varios moldes para las galletas que fabricamos (un molde para cada
forma), necesitaremos diferentes recetas para el sabor de cada una y por último
diferentes maneras de darle color a las galletas.
¿Qué son las clases en Java?
Una clase en Java se puede entender como un prototipo que define las variables y
los métodos comunes a un cierto tipo de instancias, una clase define todo lo que
caracteriza y pueden hacer una o varias instancias.
En nuestro ejemplo de la fábrica de galletas, la clase sería uno de los moldes para
galletas, junto con los métodos para colorearlas y la receta (método para prepararlas).
Quiere decir que en nuestro programa de Java tendremos una manera de especificar
las características de la galleta dado que hay diferentes moldes de galletas.
En java las clases son las matrices de las que luego se pueden crear múltiples
instancias del mismo tipo. La clase define las variables y los métodos comunes a las
instancias de ese tipo (el tipo de la clase creada), pero luego, cada instancia de esta
clase tendrá sus propios valores (su propio molde, color y receta) y compartirán las
mismas funciones.
En java, primero deberemos crear una clase antes de poder crear instancias o
ejemplares de esa clase. Evidentemente primero necesitamos los moldes y demás
para poder hacer las galletas.
¿Qué son los objetos en Java?
En Java, un objeto es básicamente una instancia de una clase (las instancias de las
que hablábamos hace un momento). Para el ejemplo de la fábrica de galletas, los
objetos vendrían siendo cada una de las diferentes galletas obtenidas de los moldes
definidos (clases), creados por medio de un proceso o "constructor" de galletas.
Muy bien, ya hemos hecho un repaso sobre el concepto de clase y objeto en Java, sin
embargo aún no sabemos cómo crearlos ni usarlos, así que vamos a ello.
¿Cómo crear una clase en Java?
Como dije anteriormente la clase es la que nos dice los componentes del ejemplar
que vamos a crear, es decir, una clase contiene los atributos y los métodos que
20
conformarán al ejemplar o instancias, de este modo al momento de crear una clase
en Java, debemos especificar el tipo y el nombre (como mínimo) de los atributos y
adicionalmente debemos especificar (si existen) los métodos o funciones, el tipo de
dato que retornan, el nombre y los parámetros que reciben dichos métodos.
Veamos la estructura básica de una clase en Java y luego veamos unos ejemplos de
clases en java un poco más complejos e ilustrativos.
Estructura básica de una clase en Java
//Le damos un nombre "MiClase" a la clase
public class MiClase
//Atributos de la clase
private String atributo1;
private int atributo2;
private float atributo3;
//Constructor con el mismo nombre de la clase
public MiClase(){}
//Métodos de la clase
public void metodo1()
//Método vacío
21
public String metodo2()
return "metodo2";
En el ejemplo anterior hemos creado una clase en Java llamada "MiClase" la cual
posee un total de tres atributos (todos ellos privados) y son de tipo String, int y float
respectivamente. Adicionalmente esta clase tiene un constructor (que siempre por
norma, debe tener el mismo nombre de la clase) el cual no recibe ningún parámetro,
aunque pueden recibir todos los parámetros que nosotros deseemos, también tiene
un método llamado "metodo1" que no retorna valor alguno (es de tipo void) y otro
método llamado "metodo2" que retorna una cadena de caracteres (es de tipo String)
con el valor "metodo2". Cabe resaltar que una clase en Java puede tener o no
métodos y atributos, sin embargo lo más normal en la mayoría de los casos es que
tenga tanto métodos como atributos que la caractericen.
Veamos ahora un ejemplo un poco más completo e ilustrativo.

Ejemplo de clases en Java
package misClases; //Se le declara un paquete
public class Animal
private String raza;
private String nombre;
private int edad;
public Animal(String nuevoNombre)
22
{
nombre = nuevoNombre; //Se le da un nombre al animal
//Método para obtener la edad del animal
public int getEdad()
return edad;
//Método para establecer la edad del animal
public void setEdad(int nuevaEdad)
edad = nuevaEdad;
//Método para obtener el nombre del animal
public String getNombre()
return nombre;
La clase Java que hemos creado para este ejemplo tiene como nombre "Animal",
pertenece al paquete "misClases" y posee los atributos raza, nombre y edad,
23
adicionalmente tenemos un constructor que recibe un nombre y se lo asigna al
animal y tres métodos encargados de obtener y establecer la edad del animal y el
restante para obtener el nombre.
Objetos en Java
Muy bien, ya hemos aprendido a la perfección cómo crear clases en java, y cuáles
son sus componentes esenciales, ahora vamos a aprender a crear objetos en Java,
cómo se hace, veremos brevemente la utilidad y funcionamiento de los constructores
y como usar los métodos
¿Cómo crear objetos en Java?
Al momento de crear objetos en Java, debemos tener claras dos cosas

indispensables, la primera es el nombre de la clase para la cual vamos a crear el
objeto y segundo el constructor que dicha clase posee, es decir, si el constructor
recibe o no parámetros.
Para crear objetos en Java, el lenguaje nos proporciona el comando new, con este
comando le decimos a Java que vamos a crear un nuevo objeto de una clase en
especifico y le enviamos los parámetros (en caso de ser necesario) según el
constructor, veamos un ejemplo.
Ejemplo de objetos en java
Vamos a crear un objeto o instancia en Java para la clase que hemos creado al
comienzo llamada MiClase. Esta clase tiene un constructor que no recibe parámetros,
por lo cual no es necesario enviar algún tipo de valor al momento de crear el objeto,
veamos entonces la sintaxis para crear un objeto del tipo MiClase en java.
MiClase miObjeto; //Declaramos una variable del tipo de la clase
miObjeto = new MiClase(); //Aquí ya hemos creado un objeto de MiClase
Otra forma de hacer y que también es válida es la siguiente:
24
MiClase miObjeto = new MiClase(); //Declaramos y creamos el objeto en una
línea
Ejemplo 2 de objetos en Java
Vamos ahora a crear un objeto o instancia para la clase Animal (la del ejemplo dos),
en esta ocasión tenemos un constructor que recibe un parámetro (el nombre del
animal) y que posee tres métodos de los cuales haremos uso para este ejemplo.
import misClases.Animal; //Importamos la clase Animal para poder usarla
public class Ejemplo
//Creamos un animal cuyo nombré será Falco
Animal miAnimal = new Animal("Falco");
//Le establecemos 3 años de edad a Falco.
miAnimal.setEdad(3);
//Mostraremos el nombre del animal por pantalla
System.out.println("El nombre es: " + miAnimal.getNombre());
//Mostramos la edad del animal por pantalla
System.out.println(" y tiene " + miAnimal.getEdad() + " años");
//Este código deberia imprimir "El nombre es: Falco y tiene 3 años"
25
Nota: Es importante notar que es similar hacer uso de método set para establecer
atributos y usar el constructor enviandole parámetros, es decir, el resultado es el
mismo al usar un constructor vacío y luego establecer los valores de los atributos por
medio de una función set o usar un constructor que reciba una serie de parámetros
que usará para establecer valores a los atributos. La diferencia radica esencialmente
en la agilidad y número de líneas, al usar el constructor y enviar los parámetros, el
constructor hace todas las asignaciones por nosotros y usamos una sola línea de
código (normalmente) mientras que al usar métodos set debemos usar un método set
por cada atributo y si tenemos cinco o más atributos ya se vuelve un poco molesto
hacerlo además de tener que usar un constructor de todas formas. Veamos un corto
ejemplo para estar más claros.
Constructor vs mutador (set)
En programación se conoce como método set al método encargado de establecerle

un valor a un atributo según un parámetro recibido (ver setEdad(...) en el ejemplo de
clases en Java).
Una pregunta que nos puede surgir es si debemos usar un constructor con
parámetros o los métodos set de los atributos para establecer los valores de los
atributos del objeto. En realidad es lo mismo en cuanto a resultados u términos
generales veamos:
Ejemplo 1: Usando constructor
public class Aclaracion
//Declaramos un constructor
public Aclaracion(int attr1, int attr2, String attr3)
26
{
atributo1 = attr1;
atributo2 = attr2;
atributo3 = attr3;
Aclaracion ac = new Aclaracion(5, 10, "x");//Creamos un objeto

enviando parámetros al constructor
System.out.println(ac.atributo1 + ", " + ac.atributo2 + ", "

+ac.atributo3);//Mostramos el valor de los atributos
//Imprime '5, 10, x'
En este ejemplo hemos hecho uso del constructor para establecerle los valores a los
atributos del objeto. Ahora hagamos lo mismo usando métodos set o accediendo
directamente a cada atributo.
Ejemplo 2: Usando métodos set
public class Aclaracion
27
public void setAtributo1(int attr1)
atributo1 = attr1;
public void setAtributo2(int attr2)
atributo2 = attr2;
public void setAtributo3(String attr3)
atributo3 = attr3;
Aclaracion ac1 = new Aclaracion();//Creamos un objeto con

constructor vacío
28
Aclaracion ac2 = new Aclaracion();//Creamos otro objeto con
constructor vacío
//Establecemos los valores de los atributos usando métodos set

de cada uno
ac1.setAtributo1(5);
ac1.setAtributo2(10);
ac1.setAtributo3("x");
//Establecemos los valores de los atributos accediendo

directamente a cada uno
ac2.atributo1 = 5;
ac2.atributo2 = 10;
ac2.atributo3 = "x";
System.out.println(ac1.atributo1 + ", " + ac1.atributo2 + ", "

+ac1.atributo3);//Mostramos el valor de los atributos de ac1
System.out.println(ac2.atributo1 + ", " + ac2.atributo2 + ", "

+ac2.atributo3);//Mostramos el valor de los atributos de ac2
Como podrás evidenciar hacer ambas cosas nos permiten llegar al mismo resultado,
sin emabrgo en el ejemplo 2, podemos ver como el número de líneas aumentó
29
considerablemente y fue más engorroso programarlo. En todo caso siempre es buena
práztica declarar los métodos set y get para cada atributo, pues si debemos modificar
el valor de un atributo cualquiera, debemos hacerlo por medio de un método get y no
creando un objeto nuevo.
Nota: En el ejemplo 2, podrás ver que hicimos uso de los métodos set para
establecer valores en el objeto ac1 mientras que para el objeto ac2 hicimos
asignaciones directas. Esto lo pudimos hacer debido a que los atributos son privados
y estamos accediendo a ellos desde la propia clase. Eso mismo no se podría hacer
desde otra clase, pues deberíamos usar el método set (que son públicos). Para más
información respecto a esto de acceso, publico, privado y demás, puedes ingresar al
artículo sobre modificadores de acceso.
Muy bien, ha sido todo en esta sección. En este punto debemos saber cómo crear
una clase, qué son atributos y métodos de una clase en Java, qué es y para qué sirve
un constructor (al menos en una forma muy básica), cómo crear objetos en Java y
cómo hacer uso de los métodos de una clase desde los objetos de la misma. Espero
entonces que todo haya quedado claro y sin fallas. De igual forma si tienes alguna
duda, comentario y/o sugerencia, siempre puedes hacer uso de la sección de
comentarios y allí con gusto responderé a cualquier comentario o duda que surja.
Ordenando nuestro proyecto Java. Uso de los

paquetes en Java (packages)
Los paquetes en Java (packages) son la forma en la que Java nos permite agrupar de
alguna manera lógica los componentes de nuestra aplicación que estén relacionados
entre sí.
Los paquetes permiten poner en su interior casi cualquier cosa como: clases,
interfaces, archivos de texto, entre otros. De este modo, los paquetes en Java
ayudan a darle una buena organización a la aplicación ya que permiten modularizar o
categorizar las diferentes estructuras que componen nuestro software.
Los paquetes en Java, adicionalmente al orden que nos permite darle a la aplicación,
también nos brindan un nivel adicional de seguridad para nuestras clases, métodos o
interfaces, pues como veremos más adelante podremos especificar si una clase o
30
interfaz en particular es accesible por todos los componentes del software (sin
importar el paquete) o si en realidad es solo accesible por las clases que estén en el
mismo paquete que ésta. Veremos con más detalle este tema del acceso más
adelante.
Ahora veamos cómo crear paquetes en Java
¿Cómo crear paquetes en Java?
Ya sabemos para qué sirven los paquetes en Java y sus características principales.
Vamos ahora a aprender cómo usarlos y qué cambios generan estos en la estructura
de nuestro proyecto.
Para declarar un paquete en Java se hace uso de la palabra reservada "package"

seguido de la "ruta" del paquete, como se muestra a continuación.
package ruta.del.paquete;
Hay varias cosas que clarificar aquí. Como verás, la sintaxis es bastante simple y
comprensible pero hay algunos detalles a tener en cuenta, veamos.
Tips o prácticas para crear paquetes en Java

 El paquete en Java se declara antes que cualquier otra cosa:
La declaración del paquete debe estar al principio del archivo Java, es decir, es
la primera línea que se debe ver en nuestro código o archivo .java. Primero se
declara el paquete, y luego podremos poner los imports y luego las clases,
interfaces, métodos, etc.
 Cada punto en la ruta del paquete es una nueva carpeta:
Cuando se escribe la ruta del paquete en Java, se pueden especificar una ruta
compleja usando el punto ".", por ejemplo en el código anterior, nuestra clase,
interfaz o archivo estará ubicado en una carpeta llamada "paquete" la cual a su
vez está en la carpeta "del" y esta también se encuentra dentro de una carpeta
llamada "ruta". De este modo si queremos por ejemplo que una clase quede al
interior de una carpeta llamada "mi_paquete" y ésta al interior de una carpeta
llamada "otro_paquete" pondríamos:
31
package otro_paquete.mi_paquete;
/*Se usa el punto para separar cada carpeta
equivale a la ruta otro_paquete/mi_paquete dentro del proyecto*/
public class mi_clase
{
}
 Prácticas recomendadas para nombrar paquetes en Java
También hay varias buenas prácticas y recomendaciones para crear y declarar
paquetes en Java. En generarl, los paquetes en java se declaran siempre en
minúsculas y en caso de ser necesario las palabras se separan usando un guión
bajo "_".
 Si no se declara un paquete (paquete por defecto):
Si decidimos no declarar un paquete para nuestra clase, ésta quedará en un

paquete que se conoce como paquete por defecto (default package), en este
paquete estarán todas las clases que no tengan un paquete declarado. Aunque
esto no genera errores de compilación ni nada parecido, siempre es
recomendable declarar un paquete a cada componente de nuestro programa
Java para poder darle diferentes niveles de seguridad o acceso a dichos
componentes y mantener todo ordenado.
 Al momento de declarar el paquete en Java:
Es común usar la primera letra en mayúscula cuando se declara una clase, pues
bien, cuando se declaran paquetes es común que todas la letras estén en
minúscula y en caso de ser varias palabras separarlas por un guion bajo "_" por
ejemplo "mi_paquete" es adecuado mientras que "MiPaquete" aunque no es
incorrecto, no es una buena práctica.
En estos momentos ya tenemos claro qué es y para qué sirve un paquete en Java,
también sabemos cómo se declaran los paquetes en Java y probablemente
tendremos una noción de los cambios que estos generan al interior de la estructura
de nuestro proyecto. A continuación veremos un ejemplo que consistirá de cuatro
32
clases diferentes en ubicaciones (paquetes) también diferentes y luego veremos
cómo queda la estructura de nuestro proyecto
Ejemplo de paquetes en Java
A continuación pondré la declaración de cuatro clases diferentes en paquetes

diferentes, cada clase se llamará "Clase_1", "Clase_2", "Clase_3" y "Clase_4"
respectivamente. Voy a jugar un poco con las carpetas donde quedará alojada cada
una de las clases para que afiances un poco más el concepto y comprendas bien el
funcionamiento de los paquetes en Java y quizá soluciones alguna duda. Por tal
motivo, te invito a intentar descifrar la ubicación exacta de cada clase al interior del
proyecto según la declaración de su respectivo paquete y ver que sí hayas entendido
adecuadamente el tema. Veamos:
 Clase número uno:
package mis_clases.clases_publicas.clase_1;
public class Clase_1
{
 Clase número dos:
package mis_clases.clase_2;
class Clase_2
{
 Clase número tres:
package mis_clases;
class Clase_3
{
33
}
 Clase número cuatro:
class Clase_4
{
En la imagen de abajo se puede apreciar la estructura final obtenida tras la

declaración de los paquetes de cada una de las cuatro clases de Java. Veamos con
detalle esto para quedar claros.
La clase número uno fue declarada en el paquete

"mis_clases.clases_publicas.clase_1" por lo tanto quedará al interior
de una carpeta llamada "clase_1" la cual estará al interior de otra
carpeta llamada "clases_publicas" y esta a su vez estará dentro de la
carpeta llamada "mis_clases". La clase número dos se le declaró el
paquete "mis_clases.clase_2" por lo tanto ha quedado al interior de
una carpeta llamada "clase_2" la cual a su vez está al interior de la
carpeta "mis_clases". A la clase número tres se le impuso el paquete
"mis_clases", esto indica que esta estará al interior de la carpeta "mis_clases". Por
último, la clase número cuatro no tiene declarado ningún paquete por lo tanto el
paquete asignado será el paquete por defecto, en otras palabras, esta clase se
mantendrá siempre en la carpeta raíz del proyecto (en netbeans y eclipse la carpeta
raíz se llama src).
Concluyendo el ejemplo de los paquetes en Java (packages)
Concluyendo finalmente con el ejemplo, tenemos que las tres primeras clases se
encuentran al interior de la carpeta "mis_clases", la cuarta clase no se encuentra allí
dado que se encuentra en la carpeta raíz del proyecto. La clase dos además de estar
34
al interior de "mis_clases" está en un carpeta propia "clase_2" y la clase uno, se
encuentra además al interior de la carpeta "clases_publicas" (si lo notaste es la única
clase publica) y luego al interior de su propia carpeta "clase_1"
Muy bien, hemos llegado al final de este contenido, espero que hayas comprendido a
la perfección cada uno de los detalles aquí explicados y que ahora domines
correctamente el concepto de paquetes en Java. Recuerda que si tienes algún
problema, duda o comentario, puedes dejarlo sin ningún temor en la sección de
comentarios. Nuestro siguiente paso es aprender a hacer uso de una clase que se
encuentra al interior de un paquete desde otra clase, por ejemplo como usar algún
método de la clase_1 desde un método de la clase_3, esto lo veremos en la sección
de Librerías en Java junto con algunas cosas más. Ahí te espero.
Uso de librerías en Java. Importar librerías estándar

de Java y librerías propias. Importar paquetes
En Java y en varios lenguajes de programación más, existe el concepto de librerías.
Una librería en Java se puede entender como un conjunto de clases, que poseen una
serie de métodos y atributos. Lo realmente interesante de estas librerías para Java es
que facilitan muchas operaciones. De una forma más completa, las librerías en Java
nos permiten reutilizar código, es decir que podemos hacer uso de los métodos,
clases y atributos que componen la librería evitando así tener que implementar
nosotros mismos esas funcionalidades.
Imaginemos cómo hacer un código para conseguir que nuestra aplicación imprima
algo por pantalla o conseguir que nuestra aplicación pueda hacer uso de arreglos
dinámicos con cualquier tipo de dato. Por medio de librerías, para imprimir texto en
pantalla en Java basta con usar System.out.print() y se puede hacer uso de ArrayList,
para tener arreglos dinámicos y demás, en Java, esto es así de fácil y todo es gracias a
las librerías, la clase System que pertenece a la librería java.lang (ésta es la librería
estándar de Java y no es necesario importarla). Ocurre de la misma forma con el
ArralyList, no podríamos hacer uso de éste si no existiera la librería java.util. Cabe
mencionar que estas librerías no solo poseen estas clases sino que poseen una gran
cantidad de clases Java adicionales que nos permiten llevar a cabo operaciones muy
complejas con gran facilidad.
35
Lo más interesante de las librerías en Java, es que nosotros también podemos
crearlas y hacer uso de ellas al interior de nuestros proyectos. Básicamente un
paquete en Java puede ser una librería, sin embargo una librería Java completa puede
estar conformada por muchos paquetes más. Al importar un paquete podemos hacer
uso de las clases, métodos y atributos que lo conforman, así que eso de las librerías
no es solo trabajo de otros sino que podemos crear nuestras propias librerías y
usarlas, incluso podemos hacer uso de un proyecto completo nuestro al interior de
otro (así de genial es esto).
Pues bien, hasta ahora todo suena muy impresionante y se entiende que es bastante
útil y que nos facilita enormemente la vida, pero ¿cómo importar una librería en Java?
¿cómo se usa una librería de Java? ¿qué es importar una librería? o mejor aún ¿qué es
import en Java? pues bien, vamos a resolver todas estas dudas a continuación.
Import en Java (importar librerías en Java)
Hacer uso de librerías tanto propias como externas, o librerías propias de Java, es
bastante fácil. Básicamente lo único que debemos saber es que para importar
librerías en Java se usa la palabra clave import seguido de la "ruta" del paquete o
clase que deseamos agregar al proyecto. Cabe resaltar que el import permite agregar
a nuestro proyecto una o varias clases (paquete) según lo necesitemos. Para
comprender y usar correctamente el import de Java, retomaremos los ejemplos
dados en la sección de paquetes.
Ejemplo de import en Java
Vamos a suponer que al interior de nuestro proyecto hemos creado cuatro clases
diferentes en paquetes diferentes, cada clase se llamará "Clase_1", "Clase_2",
"Clase_3" y "Clase_4" respectivamente.
En la imagen de abajo se puede apreciar la estructura de los paquetes de cada una de

las cuatro clases de Java. Veamos con detalle esto para quedar claros.
La clase número uno fue declarada en un el paquete

"mis_clases.clases_publicas.clase_1" por lo tanto quedará al interior
de una carpeta llamada "clase_1" la cual estará al interior de otra
carpeta llamada "clases_publicas" y esta a su vez estará dentro de la
carpeta llamada "mis_clases". La clase número dos se le declaró el
paquete "mis_clases.clase_2" por lo tanto ha quedado al interior de
36
una carpeta llamada "clase_2" la cual a su vez está al interior de la carpeta
"mis_clases". A la clase número tres se le impuso el paquete "mis_clases", esto indica
que esta estará al interior de la carpeta "mis_clases". Por último, la clase número
cuatro no tiene declarado ningún paquete por lo tanto el paquete asignado será el
paquete por defecto, en otras palabras, esta clase se mantendrá siempre en la
carpeta raíz del proyecto (en netbeans y eclipse la carpeta raíz se llama src).
Muy bien, ya sabemos la estructura de nuestros paquetes y necesitamos importarlos

al interior de alguna otra clase para hacer uso de ellas, para esto, Java nos
proporciona el comando import (tal como mencioné anteriormente). Antes de
comenzar a mostrar como importar las clases de estos paquetes, voy a dar algunas
normas y definiciones útiles al momento de importar librerías, clases o paquetes en
Java.
Antes de importar en Java...
Al igual que sucede con la declaración de los paquetes, realizar el import en Java
también tiene una localización especifica al interior del archivo java. La importación
de librerías y demás siempre debe ir después de la declaración del paquete, si la clase
no posee alguna declaración de paquete (pertenece al paquete por defecto),
entonces los import deberán estar en las primeras líneas del archivo.
Ejemplo 1: Sintaxis para import en Java
package paquete.mipaquete;
import paquete2.otropaquete.*;
class Ejemplo1{}
En el código anterior básicamente estamos diciendo que la clase contenida en el

archivo Java, estará en el paquete "paquete/mipaquete", es decir, esa será la ruta de
acceso a esa clase en el proyecto. En la siguiente línea hemos realizado el import de
un paquete. Por medio del "*" hemos indicado a Java que queremos importar todas
las clases pertenecientes a dicho paquete, puede ser una o más.
37
package paquete.mipaquete;
import paquete3.otropaquete2.MiClase;
class Ejemplo2{}
En el código anterior hemos usado el mismo paquete para la clase pero hay una
pequeña diferencia al momento del import, en esta ocasión hemos importado una
clase directamente (MiClase), es decir, como no usamos el "*" no hemos importado
todas las clases pertenecientes al paquete "paquete3.otropaquete2" sino que solo
hemos importado a "MiClase"
import paquete.mipaquete.*;
class Ejemplo3{}
En esta ocasión se puede apreciar que no hemos declarado paquete alguno para
nuestra clase y que únicamente hemos realizado el import, sin embargo este import
como tal es algo particular para nosotros, pues hemos importado TODAS las clases
pertenecientes al paquete "paquete.mipaquete" que es el paquete al cual pertenecen
las clases del ejemplo 1 y 2, esto quiere decir que al interior de la clase Ejemplo3,
podemos usar las clases Ejemplo1 y Ejemplo2.
Muy bien!! Hasta el momento ya sabemos muchas cosas acerca del import en Java,
sabemos cómo importar todas las clases pertenecientes a un paquete, también como
importar una única clase de un paquete cualquiera y vimos también que los paquetes
que nosotros mismos creamos al interior del proyecto, pueden ser usados en otras
clases de manera instantánea. Pero aún hay algo que no hemos visto y lo cual es de
gran importancia, ¿cómo importar las clases y librerías propias de Java?, pues bien
vamos a verlo.
Importando clases de Java
Importar clases propias de Java es prácticamente igual que importar clases de

nuestros propios paquetes, sin embargo, ¿cuáles son esas clases?, ¿cómo
conocerlas?, ¿cuál es el paquete al que pertenecen?, pues bien, de una vez te
comento que Java está conformado por una enorme cantidad de clases y paquetes y
38
desde mi punto de vista creo que es bastante complejo conocerlas todas, aunque si
es importante conocer las más comunes y útiles, básicamente lo que debes hacer es
ingresar a la API de Java y allí encontrarás todas las clases que componen el lenguaje,
el paquete al que pertenecen, los métodos que poseen, los atributos y una breve
explicación de cada uno de estos. Si ingresas a la documentación de Java verás que
por ejemplo existe una clase llamada ArrayList, ésta pertenece al paquete java.util,
esto quiere decir que para importarla debemos usar esa dirección, veamos:
Ejemplo 4: Importando clases de Java
import java.util.ArrayList;
class Ejemplo4{}
Aquí hemos importado la clase ArrayList y podremos hacer uso de sus componentes,
siempre y cuando sean públicos (más adelante hablaremos de esto). Hay otra forma
de hacerlo, pero posee ciertos inconvenientes:
import java.util.*;
class Ejemplo5{}
Aqui hemos importado TODAS las clases pertenecientes al paquete "java.util" lo cual
incluye la clase ArrayList y por lo tanto es funcional y válido, sin embargo esto es
bastante ineficiente, pues estamos importando todas las clases que son
aproximadamente 50 y que seguramente no usaremos. Veamos entonces cómo
importar algunas clases propias de Java.
import java.util.ArrayList;
import java.io.* //importando clases para entrada y salida (IN OUT)
import java.math.* //clases utiles para operaciones y valores matematicos
class Ejemplo6{}
39
Como podrás ver, existen muchas librerías muy útiles y es bastante sencillo hacer uso
de ellas cuando sea necesario y así ahorrarnos mucho tiempo, trabajo y esfuerzo.
Muy bien, hasta ahora hemos aprendido todo lo necesario acerca del import en Java,
sabemos cómo importar nuestra propias clases, importar todas las clases de un
paquete, también vimos que Java posee una API y que está conformada por una
enorme cantidad de Clases, interfaces, excepciones, etc. y que en cualquier
momento podemos hacer uso de cualquiera de estas.
Hemos llegado al final de este contenido, espero que hayas comprendido a la

perfección cada uno de los detalles aquí explicados y que ahora domines
correctamente el concepto de librerías en Java y del import en Java. Recuerda que si
tienes algún problema, duda o comentario, puedes dejarlo sin ningún temor en
la sección de comentarios.Puedes continuar con la sección de sistema de tipos en
Java.
Tipos primitivos en Java y tipos complejos en Java.

Variables y su uso en Java
La intención principal de esta sección es dar una introducción a lo que se refiere al
sistema de tipos de Java, el sistema de tipos en java y las variables en Java en
particular poseen una gran extensión de temas por cubrir, por lo que en este único
artículo daremos solo una mirada general. Hablaremos específicamente acerca de los
tipos de datos o variables más comunes, sus características generales, su utilidad, los
usos más comunes, entre otras cosas, sin embargo no pretendo profundizar en
detalles, pues para ello están las secciones que componen a este contenido. En la
primera sección hablaremos con detalle acerca de variables y tipos en Java y en la
segunda sección hablaremos también con detalle acerca de constantes y modificador
final en Java, pero eso será en cada sección, por lo que a este artículo corresponde,
como mencioné antes, solo veremos conceptos generales y una introducción al
sistema de tipos de Java, así que comencemos.
Cuando hablamos del sistema de tipos en Java, nos estamos refiriendo a todos los
tipos de datos (no solo los nativos o primitivos) que posee el lenguaje, es decir, el
40
sistema de tipos está conformado por todos los tipos que se le pueden asignar a las
diferentes variables dentro de una aplicación en Java y estos provienen de la
definición misma del lenguaje, es decir, nosotros no debemos crear el tipo sino que
Java ya lo trae creado para nosotros y lo podemos usar en cualquier momento. Estos
tipos de datos provienen de la librería estándar de Java y todos podemos hacer uso
de ellos.
De lo anterior entonces, podemos decir que los tipos de datos creados por el usuario
(clases) no conforman el sistema de tipos de Java, sin embargo no dejan de ser un
tipo de dato, simplemente, no son un tipo de dato estandar sino como lo dije antes,
son un tipo de dato creado por el usuario y quiza conformen un sistema de tipos
propio del usuario, mas no de Java como tal.
Como podrás imaginar Java posee una enorme cantidad de tipos de datos, sin
embargo de una manera más general, algunos de estos son más sencillos simples de
usar que otros. Veamos:
Tipos nativos o primitivos de Java
Los tipos nativos de Java, son los tipos de datos "fáciles de usar" es decir, como
veremos un poco más adelante, no es necesario crear un objeto de manera explícita
para hacer uso de ellos. Los tipos primitivos como su nombre lo da a entender, son
los tipos de datos más básicos y simples del sistema de tipos de Java y por ello es
bastante fácil usarlos. Veamos a continuación cuáles son estos tipos de datos
primitivos y sus características.
¿Cuáles son los tipos primitivos de Java?
Java posee un total de ocho tipos primitivos, que cubren todo tipo de números
(reales o decimales y enteros) cada uno con una extensión o magnitud máxima,
también cubre los valores lógicos (falso y verdadero) e incluye
caracteres. Nota: Debo advertir aquí que Java no incluye en sus tipos primitivos las
cadenas de caracteres (Strings) pues en este lenguaje (de hecho no es el único) son
representados por medio de la clase String.
 Tipo primitivo char
Este tipo de dato permite representar caracteres aislados, es decir, por medio
de un único char no podemos representar palabras completas sino más bien
letras individuales. Por ejemplo entonces la palabra "carácter" estaría
41
conformada por un total de ocho chars ‘c’, ‘a’, ‘r’, ‘a’, ‘c’, ‘t’, ‘e’ y ‘r’. Un char tiene
un peso fijo (independientemente de la letra) de 16 bit.
 Tipo boolean
El tipo de dato primitivo boolean nos permite representar valores lógicos o

booleanos (falso y verdadero). Una variable boolean, solo puede tomar dos
posibles valores false (falso) o true (verdadero), este tipo de variables son
especialmente usadas para evaluar condiciones en las cuales es necesario
conocer el valor de verdad de cierta operación lógica. Este tipo de datos
representa un bit de información, sin embargo, su tamaño no ha sido definido
(ni es importante hacerlo).
 Tipo de dato byte
Este tipo de datos representa pequeños números enteros (8 bit), puede

contener números entre -128 y 127.
 El tipo short
Este es usado para representar números enteros más grandes que byte (aunque
no demasiado) tiene un peso de 16 bit y varía entre -32768 y 32767
 Tipo primitivo int
Este tipo de dato es uno de los más populares entre una gran variedad de
programadores, pues generalmente cuando se piensa en un número entero
inmediatamente se coloca la variable como tipo int, sin embargo generalmente
int suele ser más grande de lo que llegamos a necesitar, desperdiciando así
algunos bits en memoria. Un tipo int tiene un peso de 32 bit con signo, es decir
va desde -2 a la 31 hasta 2 a la 32, aproximadamente desde -2.147’483.648
hasta 2.147’483.647.
 El tipo long
El tipo primitivo long es usado para representar números enteros realmente

grandes, del orden de -2 a la 63 hasta 2 a la 64. Vemos entonces que un long
tiene un tamaño de 64 bit y varía aproximadamente desde -
9.223’’372.036.854’775.808 hasta 9.223’’372.036.854’775.807.
42
 Tipo primitivo float
El tipo float es quizás el segundo más usado, es útil cuando queremos

representar números decimales, como por ejemplo resultados de divisiones,
raíces o similares. Son también grandes (su tamaño es de 32 bit) y cubren un
gran rango de posibles valores.
 Tipo de dato double
Este tipo es el tipo de dato numérico más grande, con este podemos
representar casi cualquier número que necesitemos, es demasiado improbable
que necesitemos un número que supere la capacidad de éste (aunque existen
unos pocos casos en los que sí), tienen un peso de 64 bit.
Muy bien ya hemos visto y conocido los tipos de datos primitivos de Java, sin
embargo como mencioné al principio de esta sección, los tipos primitivos son solo
una parte del sistema de tipos de Java, así que veamos a continuación los tipos de
datos que nos hacen falta para completar nuestro sistema de tipos:
Tipos complejos o compuestos en java
Dado que Java es un lenguaje de programación orientado a objetos no nos debe

sorprender el hecho de que una gran cantidad de los tipos que conforman su sistema
de tipos de datos sean tipos complejos (objetos que provienen de clases). La librería
estándar de Java está conformada por cientos (quizás miles) de clases que
representan en última instancia un tipo de dato particular. Cabe resaltar que
nosotros como programadores podemos crear nuestros propios tipos de datos a
partir de los que conforman el sistema propio de Java, sin embargo al ser tipos
nuestros no conforman parte del estándar de java y por ende no son parte oficial del
sistema de tipos del lenguaje. Una de las principales clases que conforman estos
tipos complejos es la clase String, los String no son un tipo primitivo (son objetos), sin
embargo está conformado por una serie (una cadena) de chars (los cuales sí son
primitivos), al ser una clase como tal, posee una serie de atributos y métodos que
podemos usar para manipular nuestra cadena de caracteres. No pretendo mencionar
todas las clases o tipos complejos que conforman el sistema de tipos de Java, sin
embargo mencionaré de manera general los que son comúnmente usados, veamos:
43
Tipos de la biblioteca estándar de java
 La clase String
Ya he hablado un poco de esta clase. Con ésta podemos crear cadenas de

caracteres con gran facilidad (Strings), de hecho se diferencia por esto de los
demás tipos complejos, pues no es necesario el uso del comando new para
crear objetos de tipo String, basta con poner la cadena entre comillas dobles
"palabra" e igualarla con una variable de tipo String y con eso bastará. En la
sección de variables y tipos en Java explicaré con mayor detalle cómo se crean
y usan los String en java. La clase String posee una serie de métodos que nos
permiten realizar tareas como determinar el tamaño de la cadena (el número de
caracteres), determinar la posición de un carácter en especifico, reemplazar
ciertas secciones de la cadena por otras, y muchas más. Puedes conocer más de
esta clase en la documentación oficial de Strings en Java
 La clase Scanner
Esta clase es muy utilizada en la actualidad porque facilita mucho la tarea de

leer la entrada de datos por teclado, es decir recibir valores escritos por el
usuario por medio del teclado. Para crear un objeto de tipo Scanner si es
necesario el uso del comando new y enviarle un parámetro específico al
constructor, de esto también hablaré con más detalle en la sección de variables
y tipos en Java. Para más información sobre esta clase, puedes visitar
la documentación oficial de la clase Scanner.
 La clase ArrayList
La clase ArrayList permite crear una "colección" de elementos al interior de sí

misma, es similar a un Vector o arreglo, y posee una gran variedad de métodos
y atributos que nos permiten por ejemplo, buscar un elemento cualquiera,
insertar un nuevo elemento, eliminarlo, entre otras. Es básicamente un arreglo
pero con una enorme cantidad de facilidades para gestionar los datos que este
contiene. También hablaré acerca de este en la sección de variables y tipos en
Java. También puedes leer la documentación oficial de la clase ArrayList para
más información
Pues bien, esto ha sido todo en esta sección, hasta este momento ya debes saber
que el sistema de tipos de Java, está conformado por tipos primitivos y tipos
complejos o compuestos, también conoces los ocho tipos de datos primitivos de Java
y sus características, al igual que algunas importantes clases o tipos complejos de la
44
librería estándar de Java. Espero que todo esto haya quedado claro y sin problemas.
De igual forma si tienes alguna duda, comentario y/o sugerencia, siempre puedes
hacer uso de la sección de comentarios y allí con gusto estaré al tanto de cualquier
comentario que pongan. El siguiente contenido habla acerca de las variables y tipos
en Java (creo que ya lo he mencionado un montón de veces :P).
Declaración, creación y uso de variables en Java.

Variables primitivas y complejas
En la sección anterior (Sistema de tipos) hablamos con detalle acerca de los tipos de
datos que conforman el sistema de Java, aprendimos acerca de los ocho diferentes
tipos de dato nativos del lenguaje y vimos también que existen tipos de datos
complejos que también conforman el sistema de datos de Java, sin embargo quedó
pendiente algo importante, pues no vimos realmente cómo hacer uso de estos tipos
de datos, básicamente aprendimos a diferenciar entre un tipo de dato y otro, pero no
aprendimos cómo declarar una variable que pertenezca a un tipo de dato concreto.
De este modo, en esta sección hablaremos acerca de la declaración de variables en
Java, el uso de los tipos de datos nativos y complejos, comencemos:
Declaración de variables en Java
Declarar variables en Java es bastante similar por no decir que igual a la gran mayoría
de los lenguajes más populares de la actualidad, básicamente debemos definir un tipo
de datos (nativo o complejo) un nombre para la variable y de manera opcional
podremos inicializarla en la misma línea y darle un valor inicial. La sintaxis para
declarar variables en Java varía dependiendo de la naturaleza del tipo de datos, es
decir si corresponde a un tipo primitivo o a un tipo complejo, veamos entonces con
detalle ambos casos:
Declaración de variables de tipo primitivo
Existen ocho diferentes tipos de datos primitivos en Java, y la sintaxis es muy

sencilla, veamos tres formas diferentes de declarar, e inicializar variables de tipo
primitivo en java:
45
//Declaración de la variable
tipo nombreVariable;
//Se le asigna un valor COMPATIBLE a la variable
nombreVariable = valor;
//Se declara la variable y se le asigna un valor al mismo tiempo
tipo nombreVariable = valor;
Acabamos de ver una forma genérica de declarar variables en Java, sin embargo
como mencioné esta forma de hacerlo coincide muy bien con los tipos nativos, sin
embargo varía un poco con los tipos complejos (ArrayList, Scanner, etc.), a
continuación pondré la sintaxis general para declarar tipos de datos complejos en
Java y luego veremos varios ejemplos de ambos casos:
Declaración de variables de tipo complejo en Java
Existe una enorme variedad de tipos complejos en la librería estándar de Java, y la

sintaxis para crear cada uno de estos es similar pero en este casi no solo varía según
la naturaleza del tipo (en este caso complejo) sino que también varía según el tipo de
dato como tal (ArrayList, Scanner, etc.), es decir en última instancia depende
el constructor del tipo complejo. La sintaxis es la siguiente
//Declaración de la variable
TipoComplejo nombreVariable;
//Se le inicializa por medio del constructor la variable
nombreVariable = new TipoComplejo(parametro);
46
//Se declara la variable y se le asigna un valor al mismo tiempo
TipoComplejo nombreVariable = new TipoComplejo(parametro);
Muy bien, con esto tenemos claro cómo declarar variables de tipo complejo en Java.
Quisiera hacer una aclaración a partir de ahora para no desviarnos de la parte
conceptual de Java. Cuando creamos una variable cuyo tipo de dato es complejo,
esta variable se convierte en lo que se conoce como objeto, es decir que si creamos
una variable de tipo ArrayList (un tipo complejo), tendremos realmente un objeto de
tipo ArrayList; esto se diferencia de las variables de tipos nativos, pues al asignarles
un valor, siguen siendo variables y no objetos, pero con los tipos complejos en Java,
estamos creando objetos como tal. En la sección de objetos y clases encontrarás mas
información de esto.
Ahora llegó el momento de hacer varios ejemplos tanto para tipos primitivos como
para tipos complejos
Ejemplos de declaración de variables y tipos en Java

Declaración de variables con tipo primitivo
A continuación pondré la declaración e inicialización de varios de los tipos de datos

primitivos de Java
//Declaración de la variable char;
char michar = 'a';//Los char se ponen entre comilla simple ' '
//Declaración de tipo booleano
boolean miboleano = true;
//Declaración de tipo byte
byte mibyte = 58; //No se debe exceder de 128
47
//Declaración de tipo short
short mishort = 500;
//Declaración de tipo int
int miint = 245474;
//Declaración de tipo float
float mifloat = 2436.2456f; //se pone una f para decir que es float
//Declaración de tipo double
double midouble = 2436.2456;
Ahora veamos cómo declarar tipos de datos complejos, para el ejemplo, veremos
cómo crear tipos complejos para ArrayList, Scanner y String.
Declaración de variables con tipo complejo
//Declaración de un String notar la S mayúscula
String miString = "Cadena txt";//Los String se ponen entre comilla doble ""
//Creación de un objeto tipo ArrayList
ArrayList miArray = new ArrayList();
//Un constructor de ArrayList no recibe parámetros.
//Creación de un objeto tipo Scanner
48
Scanner miScanner = new Scanner(System.in);
//El constructor de Scanner, recibe como parámetro la "entrada" del sistema
Eso es todo para las variables de tipo complejo, para más información de estos tipos
ingresa a documentación oficial de Strings en Java o documentación oficial de la
clase Scanner o a documentación oficial de la clase ArrayList.
Bueno, esto ha sido todo en esta sección, en el momento, debemos tener claro cómo
se declaran las variables en Java y sus correspondientes tipos de datos, ya sean
primitivos o complejos, tenemos una pequeña noción de objetos y constructores en
Java.
De igual forma si tienes alguna duda, comentario y/o sugerencia, siempre puedes
hacer uso de la sección de comentarios y allí con gusto estaré al tanto de cualquier
comentario que pongan. El siguiente contenido habla acerca de las constantes y el
final en Java. Hasta pronto
Declaración y uso de constantes en Java. Uso del

final en Java, datos final
En la sección anterior hablamos sobre variables y tipos en java y aprendimos cómo se
declara una variable, cómo se le asigna un tipo de dato específico (primitivo o
complejo). En esta sección hablaremos ya no tanto de "variables" sino más bien de
constantes. Una constante desde el punto de vista de la programación es un dato
cuyo valor no cambia durante la ejecución del programa, en otras palabras, una vez
que a una constante se le asigna un valor, este no podrá ser modificado y
permanecerá así durante toda la ejecución del programa.
Las constantes son útiles para datos o atributos para los cuales el valor no tiene por
qué cambiar, por ejemplo, el número del documento de identidad de una persona, lo
más normal es que dicho número no cambie o la fecha de nacimiento, una persona
tiene una fecha de nacimiento única e invariable, por lo tanto por ejemplo un atributo
"nacimiento" debería ser constante. Con esto podremos evitar modificaciones en
nuestro sistema que puedan causar problemas durante la ejecución del mismo.
49
En esta sección no hablaremos únicamente sobre cómo hacer que un dato cualquiera
no permanezca constante, sino también, veremos qué implicaciones tiene que una
clase, un método y un atributo sean constantes (final). Comencemos:
Constantes en Java:
La palabra clave que java ha reservado para definir constantes es la palabra "final". En
java es muy simple definir constantes, solo basta con ponerles el modificador final
antes de la declaración del tipo. Al definir un dato como constante le podremos
asignar un valor por primera vez y luego de eso no será posible cambiarle ese valor.
Una vez inicializado el dato, este no podrá cambiar su valor de ninguna forma.
Modificador final en Java:
Tal como mencioné hace un momento el modificador final es la palabra reservada

que Java definió para crear constantes. Veamos entonces la sintaxis general para
definir un dato como constante en Java:
Datos constantes en Java
final tipo nombreVble = valor;
Como se puede apreciar la sintaxis es bastante sencilla, sin embargo hay que tener
en cuenta algunas cosas: cuando vamos a declarar un dato cualquiera como final,
debemos asignarle inmediatamente un valor, es decir debemos inicializarlo de
inmediato, de lo contrario no podremos compilar nuestro código. En este punto debo
hacer una aclaración, un dato cualquiera que se encuentre por ejemplo al interior del
método main, debe ser inicializado de inmediato, sin embargo un atributo propio de
una clase no necesariamente debe ser inicializado en el mismo momento que se
declara dicho atributo, sino que puede ser inicializado también por un constructor,
dando así la posibilidad de que cada objeto especifico tenga su propio valor
constante, ingresa a continuacón para saber más sobre atributos y constructores.
Vemos el ejemplo:
Atributos constantes en java
public class Constantes

{
private final String atribConstante;
50
//Notar que no ha sido inicializado
//Constructor
Constantes(String valor)
{
//Aquí se inicializó el atributo
atribConstante = valor;
}
}
En el código anterior, podemos apreciar entonces que en el caso de los atributos de

una clase no es necesario inicializar dicho atributo una vez que éste es declarado. Sin
embargo no todo es tan bueno, pues si no lo hacemos al momento de declarar el
atributo, entonces estaremos obligados a hacerlo en el constructor de la clase. Java
debe asegurarse que el valor de una variable final sea asignado y las dos únicas
posibilidades son el constructor o en la declaración misma del atributo. Existe algo
particular con este comportamiento de Java y es que necesitamos que todos los
constructores le den valor al atributo constante (si no lo hicimos al momento de
declararlo), de este modo, si tenemos más de un constructor es obligatorio que cada
uno de ellos le asigne valor al atributo constante (final), pues no basta que uno de
ellos lo haga, Java nos permitirá compilar el código siempre y cuando todos y cada
uno de los constructores le de valor al atributo final (constante), pues si usáramos un
constructor que no le diera valor a dicho atributo, éste quedaría con valor nulo y
nunca podrá ser cambiado lo cual es inconsistente. Veamos en código de lo que
estoy hablando:
Constructores y atributos constantes en Java
public class Constantes

{
private int atributo; //Este atributo no es constante
private final String atribConstante; //Constante y no ha sido
inicializado
51
//Primer constructor
//Ver que en éste le asigna valor al atributo final
Constantes(String valor)
{
atribConstante = valor;
}
//Segundo constructor
//Éste no le asigna valor al atributo final
Constantes(int valor)
{
atributo = valor;
//Pero no se le dio valor al atributo final
//atribConstante ="";
//Lo anterior es un error!!

//Se debe descomentar la linea 22 para solucionarlo
}
Métodos y clases final
El modificador final también puede ser usado en las clases y en los métodos, de
manera similar a como se hace con los datos y los atributos, sin embargo el
significado que esto posee es diferente.
52
Final class. Clases final
Una clase final es una clase que no puede ser extendida, es decir ninguna otra clase
puede ser hija de ésta, será entonces una clase única y que no tendrá herencia o
herederos al no poder ser extendida. Veamos:
Declaramos una clase "Madre" que será final, esto quiere decir que no podrá ser
extendida por otra
//Se declara la clase como final

public final class ClaseMadre
{
//Método de la clase
{
System.out.print("Hola");
}
}
Declaramos una clase "Hija" que intentará extender de la clase "Madre", la cual es
final. Esto generará un error de compilación y no podremos ejecutar nuestro código.
//Se declara la clase como hija de madre

//Esto genera un error
public class ClaseHija extends ClaseMadre
{
53
{
}
}
Métodos final
Un método final no puede ser redefinido por una clase hija. Esto quiere decir que si
yo defino un método final en la clase X y luego la clase Y es hija de la clase X,
entonces la clase Y no podrá cambiar la definición de dicho método, puesto que éste
es final. Veamos:
Declaramos una clase "Madre" que será tendrá un método final, esto quiere decir
que dicho método no podrá ser redefinido.
//Se declara la clase como final

public class ClaseMadre
{
//Método final de la clase

public final void metodo1()
{
54
}
}
Declaramos una clase "Hija" que extenderá de la clase "Madre" sin problemas e
intentará redefinir el método1. Esto generará un error de compilación y no podremos
ejecutar nuestro código.
//Se declara la clase como hija de madre

public class ClaseHija extends ClaseMadre
{
{
System.out.print("Adios");
}
//Lo anterior genera error, pues no se puede redefinir un método final
public int metodo1(int valor)

{
return valor;
}
//Esto NO es un error, pues NO estamos redefiniendo el método
//Redefinir no es lo mismo que sobrecargar.
}
55
En el ejemplo anterior acabamos de ver como hemos intentado redefinir el método
de la clase madre y esto no generaría un error, pues método1 es final. Quiero hacer
la aclaración aquí. Redefinir no es lo mismo que sobrecargar. Cuando sobrecargamos
un método estamos cambiando la firma del método y esto lo podemos hacer
independientemente de si el método es final o no. Sin embargo redefinir el método
es intentar hacer que la clase Hija tenga el mismo método (sin sobrecargarlo), pero
que haga algo diferente, esto es lo que no podremos hacer. En este caso intentamos
que el método mostrara en pantalla "Adios" pero no podemos hacerlo, mientras que
luego SOBRECARGAMOS el método1, poniéndole un parámetro de entrada y un
valor de retorno.
Sé que esto último es bastante confuso y avanzado, sin embargo quise tocar el tema
para ir abriéndome a otras cosas y mostrando el alto potencial que tiene Java. En
otras secciones hablaré con detalle acerca de herencia en Java, todo esto de clases
Hijas, clases Madre y varias cosas más. Recuerda que cualquier duda o problema lo
puedes poner en la sección de comentarios.
Pues bien, hecha esta última aclaración doy por finalizada esta sección. Espero que
todo haya quedado lo suficientemente claro o por lo menos la parte de datos y
atributos constantes. No te preocupes si no comprender bien la parte de clases y
métodos final, pues más adelante hablaré de ellos con más detalle. No olvides dejar
tus dudas, comentarios y/o sugerencias, en la sección de comentarios. Nos leemos.
Modificadores de acceso public, protected, default

y private en Java. Encapsulamiento en Java
Los modificadores de acceso nos introducen al concepto de encapsulamiento. El
encapsulamiento busca de alguna forma controlar el acceso a los datos que
conforman un objeto o instancia, de este modo podríamos decir que una clase y por
ende sus objetos que hacen uso de modificadores de acceso (especialmente
privados) son objetos encapsulados.
Los modificadores de acceso permiten dar un nivel de seguridad mayor a nuestras

aplicaciones restringiendo el acceso a diferentes atributos, métodos, constructores
56
asegurándonos que el usuario deba seguir una "ruta" especificada por nosotros para
acceder a la información.
Es muy posible que nuestras aplicaciones vayan a ser usadas por otros
programadores o usuarios con cierto nivel de experiencia; haciendo uso de los
modificadores de acceso podremos asegurarnos de que un valor no será modificado
incorrectamente por parte de otro programador o usuario. Generalmente el acceso a
los atributos se consigue por medio de los métodos get y set, pues es estrictamente
necesario que los atributos de una clase sean privados.
Nota: Siempre se recomienda que los atributos de una clase sean privados y por
tanto cada atributo debe tener sus propios métodos get y set para obtener y
establecer respectivamente el valor del atributo.
Nota 2: Siempre que se use una clase de otro paquete, se debe importar
usando import. Cuando dos clases se encuentran en el mismo paquete no es
necesario hacer el import pero esto no significa que se pueda acceder a sus
componentes directamente.
Veamos un poco en detalle cada uno de los modificadores de acceso
Modificador de acceso private
El modificador private en Java es el más restrictivo de todos, básicamente cualquier

elemento de una clase que sea privado puede ser accedido únicamente por la misma
clase por nada más. Es decir, si por ejemplo, un atributo es privado solo puede ser
accedido por lo métodos o constructores de la misma clase. Ninguna otra clase sin
importar la relación que tengan podrá tener acceso a ellos.
package aap.ejemplo1;
public class Ejemplo1
private int atributo1;//Este atributo es privado
private int contador = 0; //Contador de registro
57
//Si un atributo es privado podemos crear método get y set ...
//... para éste y permitir el acceso a él desde otras instancias
public void setAtributo1(int valor)
contador++;//Contador que lleva el registro de ediciones del

atributo1
atributo1 = valor;//Establecemos el valor del atributo
public int getAtributo1()
return atributo1;//Retornamos el valor actual del atributo
//Get para el contador
public int getContador()
return contador;
//Notar que no ponemos un set, pues no nos interesa que el contador

pueda ser cambiado.
En el ejemplo anterior vemos lo que mencioné al comiendo, tenemos un atributo

privado y permitimos el acceso a él únicamente por medio de los métodos de get y
58
set, notemos que estos métodos son públicos y por tanto cualquiera puede
accederlos. Lo realmente interesante con los métodos get y set es que nos permiten
realizar cualquier operación como por ejemplo llevar una cuenta de la veces que se
estableció el valor para el atributo permitiéndonos mantener nuestro sistema sin
problemas. También debemos notar que debido a que los métodos get y set son
propios de la clase no tienen problemas con acceder al atributo directamente.
El modificador por defecto (default)
Java nos da la opción de no usar un modificador de acceso y al no hacerlo, el

elemento tendrá un acceso conocido como defaulto acceso por defecto que permite
que tanto la propia clase como las clases del mismo paquete accedan a dichos
componentes (de aquí la importancia de declararle siempre un paquete a nuestras
clases).
private static int atributo1;//Este atributo es privado
static int contador = 0; //Contador con acceso por defecto
public static void setAtributo1(int valor)
contador++;//Contador que lleva el registro de ediciones del

atributo1
atributo1 = valor;//Establecemos el valor del atributo
public static int getAtributo1()
59
{
return atributo1;//Retornamos el valor actual del atributo
public class Ejemplo2_1
public static int getContador()
return Ejemplo2.contador;//Accedemos directamente al contador

desde otra clase
Modificador de acceso protected
El modificador de acceso protected nos permite acceso a los componentes con dicho

modificador desde la misma clase, clases del mismo paquete y clases que hereden de
ella (incluso en diferentes paquetes). Veamos:
protected static int atributo1;//Atributo protected
60
private static int atributo2; //Atributo privado
int atributo3;//Atributo por default
public static int getAtributo2()
return atributo2;
package aap.ejemplo3_1;
import aap.ejemplo3.Ejemplo3;//Es necesario importar la clase del ejemplo 3
public class Ejemplo3_1 extends Ejemplo3
//La siguientes dos líneas generan error, pues atributo2 es privado

y atributo 3 es default
//System.out.println(atributo2);
//System.out.println(atributo3);
System.out.println(atributo1);//Sí tenemos acceso a atributo1
61
}
Modificador public
El modificador de acceso public es el más permisivo de todos, básicamente public es

lo contrario a private en todos los aspectos (lógicamente), esto quiere decir que si un
componente de una clase es public, tendremos acceso a él desde cualquier clase o
instancia sin importar el paquete o procedencia de ésta.
public static int atributo1; //Atributo publico
public static void metodo1()
System.out.println("Método publico");
package paquete.externo;
import aap.ejemplo4.Ejemplo4; //importamos la clase del ejemplo4
62
public class ClaseExterna
System.out.println(Ejemplo4.atributo1);
//Tuvimos Acceso directo por ser publico
Ejemplo4.metodo1(); //Metodo1 también es publico
A continuación y ya para finalizar, pondré una pequeña tabla que resume el

funcionamiento de los modificadores de acceso en Java.
Modificador La misma clase Mismo Subclase Otro paquete

paquete
private Sí No No No
default Sí Sí No No
protected Sí Sí Sí/No No
public Sí Sí Sí Sí
Debo aclarar algo en el caso del modificador de acceso protected y el acceso desde
suclases. Es un error común pensar que se puede crear un objeto de la clase madre y
luego acceder al atributo con acceso protected sin problemas, sin embargo esto no
es cierto, puesto que el modificador protected lo que nos permite es acceder al
atributo heredado desde el ámbito de la clase hija y no directamente. Sé que esto es
63
un poco confuso así que te invito a ver el video explicativo que aparece al comienzo
para quedar más claros.
Eso ha sido todo en esta sección, no te olvides de dejar tus comentarios y de

suscribirte a nuestras redes sociales para estar al tanto de las novedades en el sitio.
Salida de datos. Impresión de mensajes por pantalla

en Java. Uso de print y println
La salida de datos por pantalla es una de las funcionalidades fundamentales al
momento de desarrollar programas para usuarios, pues como buenos programadores
siempre debemos comunicarnos esa persona que usa nuestro programa e informarle
de todo lo que está sucediendo. La salida de datos nos permiten solicitar información
al usuario, pues sería difícil para adivinar qué es lo que esperamos que nos ingrese en
algún momento, así que básicamente no habría entrada de información si no hubiera
salida de datos por pantalla.
La salida de datos en Java, es bastante sencilla pues basta con usar una línea de
código para hacerlo. Para mostrar datos por pantalla en nuestros programas Java.
Para mostrar texto por pantalla en Java no es necesario hacer uso de librerías
importadas ni similares, pues éstas y están incluidas en la librería java.lang que
siempre es importada por defecto. Para imprimir por pantalla, se usa la clase System,
el atributo out, y su método println() o
print() así: System.out.println() o System.out.print() notar que System es una clase y
siempre debe ir con la "S" mayúscula.
Diferencia entre print() y println()
La primer pregunta que surge al ver los métodos útiles para salida de datos en Java
es en qué se diferencian (print() vs println()), básicamente ambos son útiles para
mostrar texto por pantalla y la única diferencia es que println() muestra el texto y
luego deja un salto de línea (como si presionara enter) mientras que print() no lo hace,
veamos un ejemplo para conocer bien la diferencia:
64
public class Salida
System.out.println("Hola usuario bienvenido");
System.out.println("A continuación se muestra una cuenta

regresiva");
for (int i = 10; i >= 1; i--)
System.out.println(i);//Se muestra cada valor de i (de 10 al 1)
System.out.println("Ahora, otra cuenta regresiva");
for (int i = 10; i >= 1; i--)
System.out.print(i);//Se muestra cada valor de i (de 1 a 10)
Muy bien, si ejecutamos este código, vamos a ver que el primer ciclo imprime los
números del 10 al 1 dejando una línea entre cada número, mientras que el segundo
imprime todos los número continuos sin dejar ningún espacio entre
65
ellos.
Ahora bien, a veces es necesario imprimir en pantalla mensajes más complicados y

necesitamos hacer uso de variables para ello y componer mensajes, así que veamos
un ejemplo de otras formas de imprimir datos en Java.
Concatenando y mostrando variables por pantalla
public class Salida

{
{
System.out.println("Hola usuario bienvenido");
String dia = "Lunes";

System.out.println("Hoy es " + dia); //Se componen mensajes usando
el + (concatenar)
int hora = 12;
System.out.println("Son las " + hora + " en punto");
System.out.println("Dentro de 2 horas serán las " + hora + 2 + " en

punto");//Esta línea está mal
System.out.println("Dentro de 2 horas serán las " + (hora + 2) + "

en punto");//Esta línea si muestra el resultado de 12 + 2
}
}
En el anterior código vimos que podemos incluir nuestros propios mensajes unidos
con valores de variables y que los podemos unir (concatenar) con el operador +
66
(como si estuviéramos sumando texto). Pero hay un detalle importante, hay que ser
cuidadosos al momento de concatenar números y operaciones numéricas
(especialmente la suma) pues podríamos tener errores. Si nos fijamos en el
penúltimo println() quisimos poner hora + 2 sin embargo Java entendió que
queríamos unir (concatenar) el valor de hora con un dos, dándonos como resultado
un 122 en vez del 14 que esperábamos, para solucionar esto, debemos poner la
operación matemática entre paréntesis, para que Java comprenda que queremos que
primero realice esa operación de suma y luego lo concatene, obteniendo así un 12 +
2 = 14 como esperábamos.
¡Genial! Hemos llegado al final de este contenido, ahora debes saber bien cómo
mostrar datos por pantalla y dominas la salida de datos en Java usando
concatenación y variables. Recuerda dejar tus comentarios en la sección de
comentarios. Tampoco olvides mirar las secciones de librerías en java y objetos y
clases. ¡Nos leemos!
Entrada de datos. Lectura de datos por teclado en

Java. Scanner y BufferedReader
La entrada o lectura de datos en Java es uno de los conceptos más importantes y
fundamentales al momento de interactuar con el usuario de nuestro programa. La
entrada de datos en Java, a diferencia de otros lenguajes es un poco complicada (no
demasiado) y existen diferentes formas de hacerlo, unas más complejas que otras. En
esta sección veremos dos maneras sencillas de leer datos para nuestro programa en
Java, veremos entonces dos formas de leer datos del usuario por teclado. La primera
usando las clases BufferedReader y InputStreamReader ambas de la librería java.io y la
segunda con la clase Scanner de la librería java.util.
Comencemos entonces nuestros ejemplos para la lectura por teclado en Java usando
la clase BufferedReader y InputStreamReader.
67
Lectura de datos por teclado con BufferedReader y InputStreamReader
La entrada de datos con estas dos clases se puede hacer un menos de tres líneas
según lo que necesitemos hacer, veremos cómo leer números y texto y las
particularidades de ambos casos al usar estas clases.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class EntradaJava
public static void main(String[] args) throws IOException
//Notar que readLine() nos obliga a declarar IOException
BufferedReader br = new BufferedReader(new

InputStreamReader(System.in)); //Ya tenemos el "lector"
System.out.println("Por favor ingrese su nombre");//Se pide un dato

al usuario
String nombre = br.readLine(); //Se lee el nombre con readLine()

que retorna un String con el dato
System.out.println("Bienvenido " + nombre + ". Por favor ingrese su

edad");//Se pide otro dato al usuario
68
String entrada = br.readLine(); //Se guarda la entrada (edad) en
una variable
//Nótese que readLine siempre retorna String y la clase

BufferedReader...
//no tiene un método para leer enteros, así que debemos

convertirlo.
int edad = Integer.parseInt(entrada);//Se transforma la entrada

anterior en un entero
//Si el usuario ingresó solo números funcionará bien, de lo

contrario generará una excepción
System.out.println("Gracias " + nombre + " en 10 años usted tendrá

" + (edad + 10) + " años."); //Operacion numerica con la edad
Como pudimos ver en el código anterior, ha sido bastante sencillo obtener la entrada
del usuario y almacenar ese valor en una variable. El único "problema" es
que BufferedReader únicamente posee el método readLine() para leer la entrada y este
siempre retorna String, de modo que para obtener un número debemos leer primero
como String y luego enviarle dicho String al método parseInt() de la clase Integer. Hay
que ser muy cuidadosos con Integer.parseInt() pues si el usuario no ingreso un
número sino letras, se disparará una excepción que debemos controlar (más adelante
veremos esto con detalle).
Lectura de entrada por teclado usando la clase Scanner
La clase Scanner de la librería java.util es también muy sencilla para obtener datos de

entrada del usuario, a diferencia de BufferedReader, Scanner si posee un método para
la lectura de números y para la lectura de texto que nos ayudarán a facilitar un poco
las cosas, veamos:
69
import java.util.Scanner;
public class EntradaJava2
Scanner sc = new Scanner(System.in); //Se crea el lector
System.out.println("Por favor ingrese su nombre");//Se pide un dato

al usuario
String nombre = sc.nextLine(); //Se lee el nombre con nextLine()

que retorna un String con el dato
System.out.println("Bienvenido " + nombre + ". Por favor ingrese su

edad");//Se pide otro dato al usuario
int edad = sc.nextInt(); //Se guarda la edad directamente con

nextInt()
//Nótese que ya no hubo necesidad de usar parseInt() pues nextInt

nos retorna un entero derectamente
System.out.println("Gracias " + nombre + " en 10 años usted tendrá

" + (edad + 10) + " años."); //Operacion numerica con la edad
70
}
Con este código hemos podido realizar la lectura de datos del usuario muy fácil, pues
ya no nos tuvimos que preocupar por el tipo de dato, solo debemos usar el método
adecuado según sea entero, String, float, etc.
Muy bien, creo que ha sido todo en esta sección, espero todo haya sido muy claro,
no olvides dejar tus comentarios en la sección de comentarios. No olvides darle una
mirada a las secciones de librerias en java y objetos y clases.
Los condicionales en Java. Uso declaración y

sintaxis en Java
Los condicionales en Java, son una estructura de control esencial al momento de
programar y aprender a programar. La mayoría de los lenguajes de programación
utilizados actualmente (por no decir que todos), nos permiten hacer uso de estas
estructuras para definir ciertas acciones, condiciones especificas en nuestros
algoritmos y programas.
Un condicional, permite establecer una serie de reglas al interior de nuestro

programa, que nos ayudan a determinar qué acciones llevar a cabo dadas ciertas
circunstancias. Por ejemplo, si queremos decidir cuándo dar acceso a un usuario,
dependiendo de si el nombre de usuario y contraseña son correctos. Para algo como
esto, es útil un condicional, nos permite verificar si determinada condición se cumple
(en este caso si la contraseña y el nombre de usuario son correctos) y de acuerdo a
que se cumpla o no, llevar a cabo un conjunto de acciones.
Los condicionales aumentan la "expresividad" de un programa en Java (y cualquier

otro lenguaje de programación). Es decir, nos permiten considerar diferentes
situaciones con antelación, evitando o permitiendo sortear diferentes tipos de
situaciones que son del interés de nuestra aplicación.
Puede que parezca un tanto confuso, pero, en cierto modo, un condicional permite
tomar decisiones al interior de nuestros programas. Permitiendo así que la ejecución
71
de ese programa, se haga por un camino u otro a partir de si determinada regla o
condición es cierta.
Ahora bien, existen diferentes tipos de condicionales, cada uno tiene una utilidad y
funcionalidad diferente. Cada uno, considera diferentes situaciones que se pueden
llegar a presentar durante la ejecución de un algoritmo o programa en Java. Depende
entonces del conocimiento que tengamos acerca de cada uno de los condicionales
saber determinar correctamente cuando es necesario implementar uno u otro.
Tenemos a nuestra disposición los siguientes tipos de condicionales en Java:
 Condicional If en Java
 Condicional if-else en Java
 Condicional Switch en Java
Como mencioné anteriormente, cada uno de estos condicionales tiene ciertas

características que lo hacen útil para algunos casos específicos. A lo largo de los
contenidos de esta sección veremos cada uno de estos al detalle, aprendiendo
durante el proceso los componentes de un condicional, sintaxis de los condicionales
y esas características particulares que permiten decidir cuál usar en qué momento;
veremos también el concepto de condicionales anidados, y algunas otras cositas. Por
ahora, espero que sea clara la función de un condicional en Java o en cualquier
lenguaje de programación.
Te recuerdo, que aunque intentaré profundizar bastante en cada concepto, lo haré

enfocándome hacia el uso de los condicionales en el lenguaje Java y no tanto hacia la
parte de la lógica de estas estructuras condicionales en particular. Si tienes
problemas con la correcta comprensión de la lógica y utilidad de cualquier tipo de
condicional o de los condicionales en general, te invito a que primero leas la sección
de Fundamentación de los Condicionales, en dicha sección podrás comprender
correctamente el funcionamiento de un condicional y de cada tipo de estos y
posteriormente podrás regresar a esta sección para aprender a implementar un
condicional en Java de manera mucho mas fácil y adecuada.
Nota: Recuerda dejar tus comentarios al finalizar cada contenido para seguir

enriqueciendo cada uno de estos con los aportes particulares de todos.
Muy bien, ahora que sabemos un poco acerca de las estructuras de control
condicionales (o simplemente condicionales en Java jeje) y que además sabemos que
existen varios tipos de estos, podemos comenzar a aprender y dominar cada uno de
72
estos tipos de condicionales en Java, durante los próximos artículos, vamos a hacerlo
en orden, para no complicarnos.
Acerca de los bucles o ciclos en Java. Cómo y

porqué se usan los bucles o ciclos en Java
Los ciclos o también conocidos como bucles, son una estructura de control de total
importancia para el proceso de creación de un programa. Java y prácticamente todos
los lenguajes más populares de la actualidad nos permiten hacer uso de estas
estructuras y muchas más. Un ciclo en Java o bucle en Java (como prefieras llamarlo)
permite repetir una o varias instrucciones cuantas veces lo necesitemos o sea
necesario, por ejemplo, si quisiéramos escribir los números del uno al cien no tendría
sentido escribir cien líneas de código mostrando un número en cada una de estas,
para eso y para varias cosas más (que veremos enseguida), es útil un ciclo. Un ciclo
nos ayuda a llevar a cabo una tarea repetitíva en una cantidad de líneas muy pequeña
y de forma prácticamente automática.
Existen diferentes tipos de ciclos o bucles en Java, cada uno tiene una utilidad para
casos específicos y depende de nuestra habilidad y conocimientos poder determinar
en qué momento es bueno usar alguno de ellos. Tenemos entonces a nuestra
disposición los siguientes tipos de ciclos en Java:
 Ciclo for en Java

 Ciclo while en Java
 Ciclo do-while en Java
Como mencioné anteriormente, cada uno de estos ciclos en Java tiene ciertas
características que lo hacen útil para algunos casos específicos. A lo largo de los
contenidos de esta sección de ciclos en Java veremos cada uno de estos al detalle,
aprendiendo durante el proceso los componentes, sintaxis y esas características
particulares que permiten decidir cual usar en qué momento, veremos también el
concepto de contador y acumulador que parte de la existencia de los ciclos en Java.
Te recuerdo, que aunque intentaré profundizar bastante en cada concepto, lo haré

enfocándome hacia el uso de los ciclos en el lenguaje Java y no tanto hacia la parte
de la lógica de los ciclos en particular. Si tienes problemas con la correcta
73
comprensión de la lógica y utilidad de cualquier tipo de ciclo o de los ciclos en
general, te invito a que primero leas la sección de Fundamentación de los Ciclos, en
dicha sección podrás comprender correctamente el funcionamiento de un ciclo y
posteriormente podrás regresar a esta sección para aprender a implementar los ciclos
en Java.
Muy bien, ahora que sabemos un poco acerca de las estructuras de control cíclicas (o
simplemente ciclos) y que además sabemos que existen varios tipos de ciclos,
podemos comenzar a aprender y dominar cada uno de éstos, vamos a hacerlo en
orden, para no complicarnos, así que vamos a la sección de Ciclo For (o en español
ciclo para), recuerda también que al igual que en todas las secciones de este sitio,
puedes dejar tus comentarios, ayudando así a la permanente evolución de la pagina.
Ciclo for en Java. Estructura, sintaxis y uso de un

ciclo for en Java
Los ciclos for (o ciclos para) son una estructuras de control cíclica, nos permiten
ejecutar una o varias líneas de código de forma iterativa (o repetitiva), pero teniendo
cierto control y conocimiento sobre las iteraciones. En el ciclo for, es necesario tener
un valor inicial y un valor final, y opcionalmente podemos hacer uso del tamaño del
"paso" entre cada "giro" o iteración del ciclo.
En resumen, un ciclo for es una estructura iterativa para ejecutar un mismo

segmento de código una cantidad de veces deseada; conociendo previamente un
valor de inicio, un tamaño de paso y un valor final para el ciclo.
¿Cómo funciona un Ciclo For?
Para comprender mejor el funcionamiento del ciclo for, solucionemos un pequeño

ejercicio práctico, supongamos que queremos mostrar los números pares (múltiplos
de dos :P) entre el 500 y el 1000. Con esta información inmediatamente podemos
determinar que por medio de un ciclo debemos mostrar una serie de números como
la siguiente: 500 502 504 506 ... 600 ... 852 ... 906 ... 980 .. 1000. Tenemos entonces
todo lo necesario para nuestro ciclo. Tenemos un valor inicial que sería el 500, un
valor final (1000) y tenemos un tamaño de paso que es 2 (los números pares).
74
Estamos ahora en capacidad de determinar los componentes esenciales para un ciclo
for.
Vamos a ver ahora la sintaxis de un ciclo for en Java, así estaremos listos para usarlos
en nuestros programas de ahora en adelante.
Sintaxis del Ciclo For en Java:
La sintaxis de un ciclo for es simple en Java, en realidad en la mayoría de los

lenguajes de alto nivel es incluso muy similar, de hecho, con tan solo tener bien
claros los 3 componentes del ciclo for (inicio, final y tamaño de paso) tenemos
prácticamente todo hecho
for(int i = valor inicial; i <= valor final; i = i + paso)
....
....
Bloque de Instrucciones....
....
....
Vamos ahora a ver línea por línea el anterior código para comprender todo y quedar
claros. Posteriormente veremos un ejemplo con valores reales.
Línea 1:
En esta línea está prácticamente todo lo esencial de un ciclo for. La sintaxis es simple,
tenemos una variable de control llamada i que es tipo entero (int), cabe notar que la
variable se puede llamar como nosotros lo deseemos y puede ser del tipo de
queramos también, sin embargo en la mayoría de los casos se usa la "i" como nombre
y el entero como tipo, pero somos libres de modificar esto a nuestro gusto. Esta
variable "i" se le asigna un valor inicial que puede ser cualquier número
75
correspondiente al tipo de dato asignado. Posteriormente lo que haremos será
especificar hasta donde irá nuestro ciclo por medio del valor final, ten en cuenta que
cada uno de estos componentes es separado por un punto y coma ";", también es
importante saber que la condición final puede ser cualquier cosa, mayor, menor,
mayor o igual, menor o igual, sin embargo no tiene sentido que la condición sea por
ejemplo un igual, pues nuestra variable de control siempre va a cambiar entre
valores, menores o mayores que el valor final deseado, si fuera un igual no
tendríamos un error de sintaxis, pero nuestro for básicamente no haría nada de nada.
Finalmente el ultimo componente de esta primer línea es el tamaño del paso, este
componente se especifica aumentando en la cantidad deseada la variable de control.
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como seguramente ya sabrás
indica que allí comienza el bloque de instrucciones que se ejecutaran cada vez que el
ciclo de un "giro". Esta llave no es del todo obligatoria, sin embargo si no la ponemos
solo se ejecutara dentro de nuestro ciclo la primera línea inmediatamente posterior a
la declaración del ciclo, de modo que si deseamos que se ejecuten varias líneas
dentro de nuestro ciclo, debemos usar las llaves
Línea 3 a 7:
En estas líneas es donde estarán todas las operaciones que queramos llevar a cabo
de manera iterativa durante la ejecución del ciclo, este bloque podrá tener la
cantidad de líneas necesarias incluso, como veremos más adelante dentro de estas
podría haber uno o más ciclos, así que podrías tener todo un programa dentro de un
ciclo.
Línea 8:
En esta última línea hacemos uso de la llave cerrando "}", una vez más como
seguramente ya sabrás esta nos indica que allí termina el bloque del ciclo for y se
dará por terminada la ejecución de este para continuar ejecutando el resto del
algoritmo.
No te preocupes si no comprendiste muy bien lo que acabo de escribir, estoy seguro

que con un par de ejemplos que veremos a continuación, te va a quedar todo claro.
76
Ejemplos de Ciclo For en Java
A continuación vamos a ver unos cuantos ejemplos para comprender de manera

adecuada el uso de los ciclos for en Java, recuerda que si no comprendes alguno de
estos ejemplos o tienes alguna pregunta o sugerencia sobre estos o cualquier
contenido de la sección, puedes dejarlas en la sección de comentarios
Ejemplo 1: Mostrar en pantalla los números pares
Vamos a retomar el ejemplo anterior, donde deseábamos sacar los números pares
entre el numero 500 y el 1000, es un ejemplo sencillo con el que nos aseguraremos
de haber comprendido bien lo anterior:
Solución Ejemplo 1:
for(int i=500;i<=1000;i+=2)
{//Notemos que escribir i+=2 es similar a escribir i = i + 2
System.out.println(i);
El código funcional completo sería el siguiente:
public class CicloFor
for(int i=500;i<=1000;i+=2)
77
}
Nota: Si no comprendes alguna de las líneas de estos códigos, te recomiendo visitar

los contenidos anteriores (Entrada y Salida de
Datos, Librerías ó Comentarios, Estructura de un Programa) o también puedes dejar
un comentario al final de la sección.
Ejemplo 2: Cuenta regresiva en un ciclo for
Ahora veremos otro ejemplo sencillo en cual haremos que el ciclo for también haga
sus iteraciones en sentido inverso, es decir disminuyendo el valor de la variable de
controlvamos a imprimir por pantalla una cuenta regresiva desde el número 100
hasta el 0, veamos:
Para este caso, debido a que queremos ir de un número mayor a uno más pequeño,
por lo tanto para este ejemplo el valor inicial será 100 y el valor final será 0.
Adicional, el tamaño de paso será de 1 negativo, es decir, -1, así:
for(int i = 100; i > 0; i--)
{//Notemos que escribir i-- es lo mismo a escribir i = i - 1
public class CicloInverso
for(int i = 100; i > 0; i--)
78
{
Ejemplo 3: Contador con un ciclo for
Para este ejemplo haremos algo un poco más complejo. El ejemplo consiste en contar
al interior de un ciclo for, cuántos números entre el 0 y el 10.000 son múltiplos del
20. Para ello haremos uso del operador % (módulo) que obtiene el residuo de una
división y también usaremos un pequeño condicional para verificar que el módulo sea
cero al dividir por 20.
Nota: El operador de módulo (%) obtiene el residuo de una división, por tanto cuando
el residuo es cero implica que la division es exacta y el dividendo es un múltiplo del
divisor. Por ejemplo 10%3 nos dará el residuto de dividir 10 entre 3, el cual es 1, si
calculamos 120%20 nos dará cero, pues 120 es múltiplo de 20 (20 * 6 = 120).
Para este caso el valor inicial será 0 y el valor final será 10000. Adicional, el tamaño
de paso será de 1 (este es el caso más común). Al interior del ciclo, en cada iteración
verificaremos si el número en el que estamos es divisible por 20 o no y en caso
afirmativo aumentaremos el contador en una unidad así:
Nota: Este problema se puede solucionar de maneras mucho más optimas y

adecuadas, pero para fines de comprensión y facilidad lo harémos usando un ciclo for
de uno en uno.
int contador = 0; //Iniciamos el contador en cero
for(int i = 0; i <= 10000; i++)
{//Notemos que escribir i++ es similar a escribir i = i + 1
79
if(i % 20 == 0) //Preguntamos si el residuo es 0 (es múltiplo de 20)
contador++; //Si es múltiplo aumentamos el contador en 1
//Si no es múltiplo no hacemos nada
//Mostramos el valor del contador
System.out.println(contador);
public class Multiplos
int contador = 0; //Iniciamos el contador en cero
for(int i = 0; i <= 10000; i++)
if(i % 20 == 0) //Preguntamos si el residuo es 0 (es múltiplo

de 20)
contador++; //Si es múltiplo aumentamos el contador en 1
80
//Si no es múltiplo no hacemos nada
//Mostramos el valor del contador
System.out.println(contador);
Este ciclo for nos permitirá saber que existen 501 múltiplos del número 20 en los
números del 0 al 10000.
En efecto los ciclos for, son bastante útiles, sin embargo desde el punto de vista de la
eficiencia, es recomendable evitarlos en la medida de lo posible, siempre que vayas a
usar un ciclo for, deberías preguntarte primero si es totalmente necesario o si existe
una manera más efectiva de hacerlo. Evidentemente habrá situaciones en las que
será casi que imprescindible usar el ciclo for, pues por algo existen. Está entonces en
nuestra habilidad determinar cuándo usarlos y mejor aún cómo usarlos de manera
efectiva.
Muy bien! De momento es todo en esta sección; podemos entonces continuar ahora
con el siguiente contenido que son lss funciones, recuerda también dejar tus
comentarios y/o preguntas en la sección de comentarios
Ciclo while en Java. Estructura y sintaxis. Cómo y

para qué usar un ciclo while en Java
Los ciclos while son también una estructura cíclica, que nos permite ejecutar una o
varias líneas de código de manera repetitiva sin necesidad de tener un valor inicial e
incluso a veces sin siquiera conocer cuando se va a dar el valor final que esperamos,
los ciclos while, no dependen directamente de valores numéricos, sino de valores
booleanos, es decir su ejecución depende del valor de verdad de una condición dada,
verdadera o falso, nada más. De este modo los ciclos while, son mucho más efectivos
81
para condiciones indeterminadas, que no conocemos cuando se van a dar a
diferencia de los ciclos for, con los cuales se debe tener claro un principio, un final y
un tamaño de paso.
¿Cómo funciona un Ciclo While?
Para comprender mejor el funcionamiento del ciclo while, pongamos un buen

ejemplo, imaginemos que, por algún motivo, queremos pedirle a un usuario una serie
de números cualquiera y que solo dejaremos de hacerlo cuando el usuario ingrese un
número mayor a 500. Como imaginarás, aquí no podríamos utilizar un ciclo for, pues
no tenemos idea alguna de cuándo al usuario se le va a ocurrir ingresar un número
mayor que 500 (si es que lo hace). Es algo indeterminado para nosotros. Sin embargo,
el ciclo while nos permite ejecutar una acción de forma "infinita" hasta que se cumpla
alguna condición especifica, en nuestro caso, sería que el número ingresado sea
mayor a 500. De modo que, si el usuario nos ingresa de manera sucesiva los
siguientes números 1,50,99, 49, 21, 30, 500 ..., nuestro programa no finalizara, pues
ninguno de estos números es mayor que 500. Sin embargo, si nos ingresara el
número 800, el programa finalizaría inmediatamente.
Vamos a ver ahora cómo es la sintaxis de un ciclo while en Java, así estaremos listos
para usarlos en nuestros programas de ahora en adelante cada vez que lo
necesitemos.
Sintaxis del Ciclo While en Java:
La sintaxis de un ciclo while es incluso más simple y "legible" que la del ciclo for en
Java, pues simplemente requerimos tener clara una condición de parada. En realidad,
en la mayoría de los lenguajes de alto nivel la manera de escribir un ciclo while (la
sintaxis) es incluso muy similar, así que con tan solo tener bien clara una condición de
finalización para el ciclo tendremos prácticamente todo hecho.
while(condición de finalización) //por ejemplo numero == 500
....
....
82
....
....
Vamos entonces a ver línea por línea el anterior código para comprender todo y
quedar claros. Posteriormente veremos el ejemplo planteado anteriormente y su
solución.
Línea 1:
En esta línea está prácticamente todo lo esencial de un ciclo while. La sintaxis es

bastante simple. Tenemos al interior de los paréntesis una condición cualquiera, es
decir por ejemplo "==", ">", "<", ">=", "<=", "!=" o algunas más que se nos puedan
ocurrir. Esta condición que especifiquemos allí, es la que permitirá que el ciclo se siga
ejecutando hasta que en algún momento esta misma condición deje de cumplirse, de
esta forma si por ejemplo estamos verificando que un número cualquiera sea igual a
50, el ciclo se ejecutará solo cuando dicho número sea exactamente igual a 50. En
cuanto su valor cambie a cualquier otro, el ciclo while finalizará y continuará con el
resto de la ejecución del programa. De esta forma, es evidente que la condición que
allí ingresemos siempre deberá tomar un valor booleano (true o false).
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como sabemos indica que allí
comienza un bloque de instrucciones que se ejecutaran cada vez que el ciclo de un
"giro". Esta llave no es del todo obligatoria, sin embargo, si no la ponemos solo se
ejecutara dentro de nuestro ciclo while la primera línea inmediatamente posterior a
la declaración del ciclo, de modo que si deseamos que se ejecuten varias líneas
dentro de nuestro ciclo, debemos usar las llaves
Línea 3 a 7:
ciclo.
83
Línea 8:
seguramente ya debemos saber esta nos indica que allí termina el bloque del ciclo
while y se dará por terminada la ejecución de este para continuar ejecutando el resto
del algoritmo.

que con un par de ejemplos que veremos a continuación, te va a quedar todo claro
Ejemplos de Ciclo While en Java

adecuada el uso de los ciclos while en Java, recuerda que, si no comprendes alguno
de estos ejemplos o tienes alguna pregunta o sugerencia sobre estos o cualquier
contenido de la sección, puedes dejarlas en la sección de comentarios
Ejemplo 1: Pedir números por pantalla hasta que alguno sea mayor a 500
Vamos a retomar el ejemplo anterior, donde queremos hacer que nuestro programa
le pida a un usuario una serie de números cualquiera y que solo dejaremos de hacerlo
cuando el usuario ingrese un número mayor a 100, una vez mas es un ejemplo
sencillo con el que nos aseguraremos de haber comprendido bien todos los
conceptos anteriores:
Para solucionar esto, debemos tener clara cuál va a ser la condición que se debe
cumplir para que el ciclo este pidiendo el numero contantemente, el ciclo se va a
detener solo cuando el numero ingresado sea mayor que 500, así que la condición
para que se siga ejecutando es que el numero sea menor o igual a 500, ¿Comprender
la lógica?, si para que se detenga el número debe ser mayor a 500, entonces para
seguirse ejecutando el número debe ser menor o igual a 500, veámoslo entonces
Scanner sc = new Scanner(System.in);
int numero = sc.nextInt();
84
while(numero <= 500)
System.out.println("Ingrese un numero ");
numero = sc.nextInt();
El código funcional completo y un tanto más amigable para el usuario sería el

siguiente:
public class CicloWhile
int numero = sc.nextInt();
while(numero <= 500)
System.out.println("Ingrese un numero ");
85
}
Nota: Si no es clara alguna de las líneas de estos códigos, te recomiendo visitar los
contenidos anteriores (Entrada de Datos, Estructura de un Programa) o también
puedes dejar un comentario al final de la sección con tu pregunta.
En efecto los ciclos while, son bastante útiles, sin embargo, desde el punto de vista
de la eficiencia al igual que con los ciclos for, es recomendable evitarlos en la medida
de lo posible, siempre que vayas a usar un ciclo while o cualquier tipo de ciclo en
realidad, deberías preguntarte primero si es totalmente necesario o si existe una
manera más efectiva de hacerlo. Evidentemente habrá situaciones en las que será
casi que imprescindible usar el ciclo, pues por algo existen, esta entonces en nuestra
habilidad determinar cuándo usarlos y mejor aun como usarlos de manera efectiva.
Muy bien. De momento, es todo en esta sección, recuerda también dejar tus
comentarios y/o preguntas en la sección de comentarios.
Ciclo do-while en C++. Estructura, sintaxis y

diferencias con el while. Cómo y cuándo usar un
ciclo do-while en C++
Los ciclos do-while son una estructura de control cíclica, que nos permiten ejecutar
una o varias líneas de código de forma repetitiva sin necesidad de tener un valor
inicial e incluso a veces sin siquiera conocer cuándo se va a dar el valor final. Hasta
ahí son similares a los ciclos while, sin embargo, el ciclo do-while nos permite añadir
cierta ventaja adicional puesto que nos permite ejecutar primero el bloque de
instrucciones antes de evaluar la condición necesaria. De este modo, los ciclos do-
while, son más efectivos para algunas situaciones específicas. En resumen, un ciclo
do-while, es una estructura de control cíclica que permite ejecutar de manera
repetitiva un bloque de instrucciones sin evaluar de forma inmediata una condición
especifica, sino evaluándola justo después de ejecutar por primera vez el bloque de
instrucciones en su interior. Por lo tanto, un ciclo do-while ejecutará las instrucciones
que contiene al menos una vez, mientras que el while podría no hacerlo ni una vez.
86
¿Cómo funciona un Ciclo Do-While?
Para comprender mejor el funcionamiento del ciclo while, usemos de nuevo el

ejemplo de la sección anterior sobre el ciclo while. Imaginemos entonces que por
algún motivo, queremos pedirle a un usuario una serie de números cualquiera y que
solo dejaremos de hacerlo cuando el usuario ingrese un número mayor a 500. Como
vimos anteriormente, esto se puede hacer por medio de un ciclo while, pero vamos
ahora a ver como lo podemos hacer usando un ciclo do-while mejorando así un poco
nuestro algoritmo, evitando ciertas líneas, tal como se dijo con el ciclo while. De
hecho, aquí estamos en la situación de no tener ni idea de cuándo al usuario se le va
a ocurrir ingresar un número mayor que 500, pues es algo indeterminado para
nosotros, sin embargo, el ciclo while y en efecto el do-while nos permite ejecutar
cierta acción de forma "infinita" hasta que se cumpla alguna condición específica, en
nuestro caso, sería que el número ingresado sea mayor a 500. De modo que, si el
usuario nos ingresa de manera sucesiva los siguientes numeros, 1,50,99, 49, 21, 30,
500 ..., nuestro programa no finalizará, pues ninguno de estos números es mayor que
500, sin embargo si nos ingresara el número 800, el programa finalizaría
inmediatamente.
De nuevo, en el caso del do-while las instrucciones se ejcutan al menos una vez, lo
cual nos permitíría solicitar el número al usuario dentro del ciclo, evitando repetir la
asignación de la variable. Nuestro código queda más organizado así.
Vamos a ver ahora cómo es la sintaxis de un ciclo do-while en Java, así estaremos
listos para usarlos en nuestros programas de ahora en adelante cada vez que lo
necesitemos
Sintaxis del Ciclo Do-While en Java:
La sintaxis de un ciclo do-while es un tanto más larga que la del ciclo while en Java,
sin embargo no se hace más complicado, de hecho con tan solo tener bien clara una
condición de finalización para el ciclo tendremos prácticamente todo terminado.
do
....
87
....
....
....
while(condición de finalización); //por ejemplo numero != 23
Vamos entonces a ver línea por línea el anterior código para comprender todo y
quedar claros. Posteriormente veremos el ejemplo planteado anteriormente y su
solución.
Línea 1:
Esta línea es por decirlo así, la parte novedosa del ciclo do-while, esta expresión no
evalúa ninguna condición ni nada, simplemente da paso directo al bloque de
instrucción y luego permite la evaluación de la condición.
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como sabemos indica que allí
comienza un bloque de instrucciones que se ejecutaran cada vez que el ciclo de un
"giro". Esta llave no es del todo obligatoria, sin embargo, si no la ponemos solo se
ejecutará dentro de nuestro ciclo la primera línea inmediatamente posterior a la
instrucción do, de modo que si deseamos que se ejecuten varias líneas dentro de
nuestro ciclo, debemos usar las llaves. En lo personal, es preferible poner siempre las
llaves sin importar cuantas líneas se vayan a ejecutar, es una buena práctica de
programación y te puede evitar dolores de cabeza
Línea 3 a 7:
ciclo.
88
Línea 8:
seguramente ya debemos saber esta nos indica que allí termina el bloque de
instrucciones que se ejecutarán de manera cíclica y se dará por terminada la
ejecución de este para continuar ejecutando el resto del algoritmo.
Línea 9:
La línea 9 en el ciclo do-while, tiene la misma importancia y función que l alinea 1 en

la sección del ciclo while, cabe resaltar que simplemente evalúa la condición y define
si se cumple o no para seguir con la ejecución del ciclo o con la del resto del
algoritmo, de este modo podemos ver que el ciclo while y el do-while son muy
similares, con la pequeña diferencia en que en uno se evalúa la condición desde el
principio y en la otra al final de cada ciclo.

que con un par de ejemplos que veremos a continuación, te va a quedar todo claro
Ejemplos de Ciclo Do-While en Java

adecuada el uso de los ciclos while en Java, recuerda que si no comprendes alguno
de estos ejemplos o tienes alguna pregunta o sugerencia sobre estos o cualquier
contenido de la sección, puedes dejarlas en la sección de comentarios.
Ejemplo 1: Pedir números por pantalla hasta que alguno sea mayor a 500
Vamos a retomar el ejemplo anterior, donde queremos hacer que nuestro programa
le pida a un usuario una serie de números cualquiera y que solo dejaremos de hacerlo
cuando el usuario ingrese un número mayor a 500, una vez más es un ejemplo
sencillo con el que nos aseguraremos de haber comprendido bien todos los
conceptos anteriores, vamos a ver cómo hacer lo mismo con dos tipos de ciclos
diferentes (el while y el do-while), sin embargo vamos a ver como con uno es más
directo que con el otro, mejorando la calidad de nuestro código:
Para solucionar esto, debemos tener clara cuál va a ser la condición que se debe
cumplir para que el ciclo este pidiendo el numero constantemente. El ciclo se va a
detener solo cuando el numero ingresado sea mayor que 500, así que la condición
89
para que se siga ejecutando es que el numero sea menor a 500. Si para que se
detenga, el numero debe ser mayor a 500, entonces para seguirse ejecutando el
numero debe ser menor o igual a 500, veámoslo entonces
int numero;
do
System.out.println("Ingrese un numero: ");
while(numero <= 500);
El código funcional completo y un tanto más amigable para el usuario sería el

siguiente:
public class CicloDoWhile
int numero;
90
do
System.out.println("Ingrese un numero: ");
while(numero <= 500);
Nota: Como podrás comprobar, comparando con el artículo anterior, ambos códigos

hacen lo mismo, ya sea el del ciclo while o del ciclo do while. Sin embargo con el ciclo
do-while, hemos obtenido un beneficio interesante, primero que todo hemos podido
evitar tener que inicializar la variable "numero", segundo también pudimos eliminar
las líneas repetidas donde se pedía el numero por fuera del ciclo y luego al interior
del ciclo, aquí lo hicimos solo al interior, pues la condición se evaluaba mucho más
abajo.
Nota 2: Si no comprendes alguna de las líneas de estos códigos, te recomiendo visitar
los contenidos anteriores (Entrada de Datos, Salida de
Datos, Librerías, Comentarios y Estructura de un Programa) o también puedes dejar
un comentario al final de la sección con tu pregunta.
Diferencias entre el ciclo do-while en Java y el ciclo while
Cuando vemos por primera vez el ciclo do-while, se nos viene de inmediato la
pregunta de cuál es la diferencia entre un do-while y un while. Y no quedamos muy
seguros de poder saber cuándo usar uno u otro, así que aquí te explico.
La diferencia es que el do-while, primero ejecuta la acción y luego evalúa la

condición, mientras que el while evalúa la condición antes que cualquier cosa. Esto
quiere decir, que el ciclo while podría no ejecutar ni siquiera una vez lo que tenga en
su interior, mientras que el do-while te asegura que lo que pongas dentro se ejecute
mínimo una vez, pues primero ejecuta y luego evalúa la condición.
91
Ejemplo de diferencias entre un do-while en Java y un while
Como siempre, un ejemplo puede ayudarnos mucho más a comprender cuándo usar
un do-while en lugar de un while en Java, así que vamos a implementar el siguiente
ejemplo:
Vamos a suponer que queremos mostrar un menú de opciones a un usuario de

nuestro programa y que mientras la opción ingresada no sea cero, entonces no
finalizamos el programa.
Implementando el ejemplo del menú de opciones con un ciclo do-while (el recomendado)
int opcion = 0;
do
System.out.println("Ingrese 1 para mostrar mensaje");
System.out.println("Ingrese 2 para hacer algo más");
System.out.println("Ingrese 0 para salir");
System.out.println("Ingrese una opción a ejecutar");
92
opcion = sc.nextInt();
while(opcion <= 500);
Como puedes ver y comprobar, es un código sencillo y mientras que el usuario del
programa no ingrese cero en la consola, el programa seguirá mostrando las diferentes
opciones.
Es importante notar que, incluso aunque la variable "opcion" se inició en cero, el ciclo
do-while mostró las opciones sin problemas y no llegó a evaluar su valor, sino
únicamente después de que el usuario la ingresó. Veamos ahora el mismo ejercicio,
pero usando un ciclo while.
Implementando el ejemplo del menú de opciones con un ciclo while (no recomendado)
int opcion = -1;
93
//Mostramos el menú hasta que la opción sea cero
while(opcion != 0)
System.out.println("Ingrese 1 para mostrar mensaje");
System.out.println("Ingrese 2 para hacer algo más");
System.out.println("Ingrese 0 para salir");
System.out.println("Ingrese una opción a ejecutar");
opcion = sc.nextInt();
En este caso, vemos que, por supuesto, con el ciclo while también podemos
conseguir lo mismo, PERO modificando algunas cosas con relación a la opción. En
general, el mayor aspecto negativo de usar un while en este caso, en lugar de un do-
while, es que ya hemos asignado la variable opción sin siquiera habérsela solicitado al
usuario por primera vez, lo cual nos obliga a darle un valor inicial a la variable
"opcion" (un -1), para asegurarnos de que el ciclo se ejecute al menos una vez y el
usuario tenga la opción de ver el menú e ingresar la acción que desea ejecutar.
Muy bien, con eso deberíamos tener un caso claro en el que es mejor usar un do-
while que un while en Java. Veamos ahora algunas conclusiones.
Conclusiones sobre el ciclo do-while en Java
En efecto, los ciclos do-while son bastante útiles. Sin embargo, como con cualquier
ciclo desde el punto de vista de la eficiencia al igual que con los ciclos for, es
recomendable evitarlos en la medida de lo posible, siempre que vayas a usar un ciclo
do-while o cualquier tipo de ciclo en realidad, deberías preguntarte primero si es
94
totalmente necesario o si existe una manera más efectiva de hacerlo. Evidentemente
habrá situaciones en las que será casi que imprescindible usar el ciclo, pues por algo
existen. Está entonces en nuestra habilidad determinar cuándo usarlos y mejor aún
cómo usarlos de manera efectiva.
Finalmente, tener claro, tal como se mostró en este artículo, cuándo usar un do-while
en lugar de cualquier otro ciclo de Java.
Muy bien, de momento, es todo en esta sección, podemos entonces continuar ahora
con el siguiente contenido. Recuerda también dejar tus comentarios y/o preguntas
en la sección de comentarios.
95

Aprende Java

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

Aprende Java

Cargado por

Copyright:

Formatos disponibles

Aprende a programar desde cero en Java.

En esta sección responderemos estas preguntas y aprenderemos en qué consiste

La última actualización de este artículo fue hace 1 año

Instalación y configuración de Java y un entorno de

Nota: Al final de la descripción de cada uno de los editores o entornos de desarrollo

Desde lo personal, como mencioné hace un momento, actualmente utilizo Netbeans.

NetBeans es un entorno de desarrollo integrado libre, hecho principalmente para

Nota: Netbeans ha estado en un proceso de transición de Oracle (anterior

Puedes Descargar la versión más reciente de Netbeans aquí.

Puedes Descargar IntelliJ para cualquier sistema operativo acá.

Eclipse es un entorno de desarrollo integrado de código abierto multi-plataforma que

JCreator es un entorno de desarrollo que posee una versión profesional y otra

El JDK (Java Development Kit) es el conjunto de librerías, paquetes, clases, métodos,

Puedes encontrar el JDK aquí

La maquina virtual de Java, en términos sencillos, es la encargada de comprender lo

Creando nuestro primer proyecto Java usando

Un proyecto en un entorno de desarrollo nos permite dar un orden y una

¿Cómo crear y ejecutar un proyecto en Netbeans

En la mayoría de los entornos de desarrollo el proceso es bastante similar, pero aquí

Como primer paso, necesitamos abrir nuestro entorno de

Para crear el proyecto, debemos seguir

Hecho esto, se nos

pidiéndonos alguna información de nuestro proyecto. Para este ejemplo, como

Hacemos clic derecho sobre el proyecto,

Aparecerá una ventana

En cuanto tengamos nuestro proyecto y nuestra clase creados podremos crear

public class MiPrimeraClase

public static void main(String[] args)

La última actualización de este artículo fue hace 1 año

Domina los conceptos principales de Java y la POO:

Un ejemplo para programar en Java

A modo de ilustración, imaginemos que tenemos una fábrica de galletas, tenemos

¿Qué son las clases en Java?

Una clase en lenguaje de programación Java se puede entender como un prototipo

¿Qué son los objetos en Java?

En el ámbito del lenguaje de programación Java, un objeto es básicamente una

El gran beneficio de todo esto es la encapsulación. En java el código fuente de un

¿Qué son los mensajes en Java?

En nuestro ejemplo de la fábrica de galletas, los mensajes vendrían siendo la manera

¿Qué es la herencia en Java?

Ejemplo de una clase en Java

public class Galleta

public Galleta fabricar_galleta()

De momento no pretendo profundizar mucho con respecto a esto. En el código

¡Listo! Vamos a la siguiente sección para conocer un poco acerca de

La última actualización de este artículo fue hace 2 años

Documentación de programas en Java. Uso de

Comentarios en Java de una sola línea:

//Declaración del método principal

Comentarios en Java de múltiples líneas:

// Declaración del método principal

Comentarios de documentación en Java (Javadoc):

Los comentarios de documentación, también conocidos como Javadoc, son de

Estos comentarios además requieren de algunos "componentes" para indicar los

La última actualización de este artículo fue hace 4 años

Ejemplo simple de programación en Java. Un

No te preocupes si te es difícil esto del argumento, más adelante te quedará más

La estructura básica de un programa desarrollado usando Java es la siguiente:

public class Nombre_Clase

La primera línea de nuestro código ha declarado una clase llamada "nombre_clase"

La línea número tres contiene la declaración del mé main, en cualquier aplicación de

No te preocupes si no entiendes bien esto de retorno o no retorno, entero y eso,

Ejemplo de un programa de Java básico