El documento describe los comandos de Java y las sentencias if-else y switch en Java. Explica que los comandos de Java son opciones que modifican el comportamiento del intérprete Java y que las sentencias if-else y switch son estructuras de control de flujo que permiten ejecutar código de manera condicional.

1. Jenifer Patricia Monroy Sanchez
3° Am
Disena Software de Aplicacion
Utilizando Programacion Orientada a
Objetos
M.C.A Margarita Romero Alvarado

2. Comandos de java
-Xdebug Permite que el jdb (depurador de código
Java -Java debugger-) se conecte a si
mismo a la sesión de java. Cuando se
utiliza esta opción, java muestra una
contraseña, la cual ha de ser introducida
cuando comienza la sesión de
depuración.
-classpath path Especifica el camino que java usa para
buscar las clases. Sobreescribe el
establecido por defecto o la variable de
entorno CLASSPATH si ésta ha sido
establecida anteriormente. Los directorios
en la variable CLASSPATH deben estar
separados con punto y coma (;). El
formato general para el path es:
.;<tu_camino>
Por ejemplo:
.;C:usersafqclasses;C:jdkclasses
-help Imprime un mensaje indicando la forma
de la llamada
-jar fichero_jar Ejecuta un programa Java encapsulado
en un fichero JAR. En lugar de
referenciarlo en la línea de comandos,
java coge la clase inicial que el fichero jar
indica en la cabecera Main-Class. Por
ejemplo, si el punto de entrada al
programa es
COM.MiEmpresa.MiPaquete.MiClase.mai
n(), lo que aparecería en esta entrada

3. sería:
Main-Class:
COM.MiEmpresa.MiPaquete.MiClase
-Xmx x Establece el tamaño máximo de la
memoria del recolector de basura
(garbage collector) a x. El valor por
defecto es 16 megabytes de memoria. x
debe ser mayor o igual a 1000 bytes. Por
defecto, x se toma en bytes, pero se
puede especificar en kilobytes o
megabytes poniendo después de x la letra
"k" para kilobytes y "m" para megabytes.
-Xms x Establece el tamaño de inicio de la
memoria del recolector de basura
(garbage collector) a x. El valor por
defecto es 1 megabyte. x debe ser mayor
que 1000 bytes. Por defecto, x se toma en
bytes, pero se puede especificar en
kilobytes o megabytes poniendo después
de x la letra "k" para kilobytes y "m" para
megabytes.
-Xnoasyncgc Desactiva el recolector asíncrono de
basura. Cuando el recolector está
activado no actúa a menos que éste sea
explícitamente llamado o el programa
corra fuera de memoria. Normalmente el
colector de basura (garbage collector) se
ejecuta como una tarea asíncrona en
paralelo con otras tareas.
-Xnoclassgc Desactiva el recolector de basura de
clases Java. Por defecto, el intérprete
Java reclama espacio para clases Java,
aunque no se usen, durante la recolección
de basura
-Xprof Arranca Java con el profiler activado. Por
defecto, los resultados de la
comprobación de la ejecución del
programa Java se guardan en ./java.prof.
Esta opción solamente funciona con
java_g.
-Xprof:fichero Arranca Java con el profiler activado. Esta
forma permite que se especifique un
fichero para guardar los resultados del

4. estudio de la ejecución del programa
Java, diferente al utilizado por defecto.
Esta opción solamente funciona con
java_g.
-Xss x Cada hilo de ejecución Java tiene dos
pilas: una para el código Java y otra para
el código C. Esta opción establece el
tamaño máximo de la pila mediante el
valor x que puede ser usada por el código
C en un hilo. Todos los hilos que resultan
de la ejecución del programa pasado a
java tienen una pila C de tamaño x. La
unidad por defecto para x son bytes. x
debe ser mayor o igual a 1000 bytes. Se
puede modificar el significado de x
añadiendo la letra "k" para kilobytes o la
letra "m" para megabytes. El tamaño por
defecto de la pila es 128 kilobytes ("-ss
128k").
-Xoss x Cada hilo de ejecución Java tiene dos
pilas: una para el código Java y otra para
el código C. Esta opción establece el
tamaño máximo de la pila mediante el
valor x que puede ser usada por el código
Java en un hilo de ejecución. Todos los
hilos que resultan de la ejecución del
programa pasado a java tienen una pila
Java de tamaño x. La unidad por defecto
para x son bytes. x debe ser mayor o igual
1000 bytes. Se puede modificar el
significado de x añadiendo la letra "k"
para kilobytes o la letra "m" para
megabytes. El tamaño por defecto de la
pila es 400 kilobytes ("-oss 400k").
-X Imprime ayuda sobre las opciones no
estándar
-v, -verbose Hace que java imprima un mensaje en la
salida estándar cada vez que se carga el
archivo de una clase.
-Xverify Ejecuta el verificador de todo el código.
-Xverifyremote Ejecuta el verificador de todo el código
que es cargado en el sistema a través de
un cargador de clases. verifyremote es el
valor por defecto para el intérprete.

5. -verbosejni Imprime mensajes relacionados con JNI,
incluyendo información sobre los métodos
nativos que han sido linkados y avisos
sobre creación de excesivas referencias
locales.
-verbosegc Hace que el recolector de basura imprima
mensajes cada vez que libera memoria.
-version Imprime información sobre la
versión.
-Dpropiedad=valor Redefine el valor de una propiedad.
propiedad es el nombre de la propiedad
cuyo valor se quiere cambiar y valor es
valor a ser asignado. Por ejemplo, la línea
siguiente.
%java -
Dawt.button.color=gre
en ...
establece el valor de la propiedad
awt.button.color a "green" (verde). java
acepta cualquier numero de opciones -D
en la línea de comandos.
Sentencias
Sentencia if-else
Queremos realizar una división de enteros. Es fácil, ya sabemos como hacerlo, utilizando
variables y operadores. Pero nos queda un mal recuerdo con la división por cero. Podemos
establecer una condición que permita la división para todos los números y que rechace
cualquier divisor con cara de cero. Disponemos de dos opciones : realizar o no la división.
También una condición: el divisor sea distinto de cero. Esto se parece mucho a una selección
simple.
La estructura de selección simple en Java se realiza mediante la sentencia if (si, en ingles). La
sintaxis es la siguiente :

6. if (condición) sentencia;
La condición es una expresión booleana. La sentencia se ejecuta solamente si la expresión
booleana es verdadera.
Retomando el problema de la división, incorporamos una estructura de selección para realizar
la operación libre de ceros.
public class DivisionSegura {
public static void main(String args[]){
int x = 12;
int y = 0;
int z = 0;
if( y !=0 ) z = x / y;
System.out.println("El resultado es : " + z);
}
}
En el programa, la variable x tiene el valor del dividendo, la y el divisor y la z el cociente. La
condición es una expresión que arroja un valor booleano. En este caso se utiliza un operador
relacional que verifica si y es distinto de 0. Si esta condición se cumple realiza la división. En
caso contrario se saltea la división y solo imprime el valor de z, que hemos inicializado
convenientemente antes de la operación.
¿Qué ocurre si la condición no se cumple? En este caso nada. Podemos agregar una serie de
instrucciones que se ejecutarán solo si la condición no se cumple. Para esto tendremos que
agregar la sentencia else. La estructura de selección quedará así:
if (condición) sentencia 1;
else sentencia 2;
Si la condición es verdadera se ejecuta la sentencia 1 en caso contrario se ejecuta la
sentencia 2. Ambas sentencias nunca se ejecutarán al mismo tiempo, son excluyentes.
Ahora ampliemos el programa para mostrar una advertencia en el caso que se encuentre cara
a cara con un cero siniestro.
public class DivisionSegura {
public static void main(String args[]){

7. int x = 12;
int y = 0;
int z = 0;
if( y !=0 ) z = x / y;
else System.out.println("Atención! se pretende dividir por
0");
System.out.println("El resultado es : " + z);
}
}
El programa nos quedó mas completo. Con la cláusula else incluimos otra alternativa de
acción. Pero algo anda suelto. Este programa siempre muestra un resultado, se cumpla o no
la condición. El mensaje por pantalla no está incluido en la estructura de selección.
Tendremos que colocarlo dentro del sector de sentencias que se ejecutarán cuando la
condición sea verdadera. Para agrupar las sentencias se utilizan las llaves ( { } ) Indicarán el
inicio y el fin de un bloque de sentencias.
Probemos como queda con un bloque
public class DivisionSegura {
public static void main(String args[]){
int x = 12;
int y = 2;
int z = 0;
if( y !=0 ) {
z = x / y;
System.out.println("El resultado es : " + z);
} else {
System.out.println("Atención! se pretende dividir por
0");
}
}
}
Las buenas prácticas en defensa de un código mantenible han dictaminado que utilicemos las
llaves en todo momento, aún en el caso que utilicemos una sola sentencia.
if (condición) {
sentencia;

8. } else {
sentencia;
}
Lamentablemente no siempre nos encontraremos con condiciones tan sencillas. Muchas
veces tendremos que recurrir a proposiciones compuestas para formar una condición. Para
ello podemos recurrir a operadores relacionales o lógicos. Recuerden que siempre debe dar
como resultado un valor booleano.
Supongamos que deseamos saber si un año es bisiesto. Sabemos que debe ser múltiplo de 4.
Para esto tendremos que verificar si el módulo es igual a cero.
año % 4 == 0
Pero no debe ser múltiplo de 100.
( año % 4 == 0 ) && ( año % 100 != 0 )
A menos que sea múltiplo de 400.
((( año % 4 == 0 ) && ( año % 100 != 0 )) || ( año % 400 == 0 ))
Formamos una proposición compuesta con conectores lógicos. Ahora vamos a incorporarlo en
una estructura se selección.
if ((( año % 4 == 0 ) && ( año % 100 != 0 )) || ( año % 400 == 0 )) {
System.out.println("Es bisiesto");
} else {
System.out.println("No es bisiesto");
}
Los conectores lógicos nos permiten simplificar la estructura. Sin ellos nos veríamos en la
necesidad de anidar las sentencias. Veamos que ocurre si en elejemplo anterior descartamos
el AND y el OR.
if ( x % 4 == 0 ) {
if ( x % 100 == 0 ) {
if ( x % 400 == 0 ) {

9. System.out.println("Es bisiesto");
} else {
System.out.println("No es bisiesto");
}
} else {
System.out.println("Es bisiesto");
}
} else {
System.out.println("No es bisiesto");
}
Parece complicado, pero nos demuestra muchas cosas. En primer lugar observamos que se
pueden anidar las sentencias if-else. Cada resultado de una condición puede caer en una
nueva comprobación para formar una estructura compleja de selección.
También vemos que hay cierta relación entre conectores lógicos y la estructura.
Conjunción
if (condición1 && condición2){
sentecia1;
} else {
sentencia2;
}
if ( condición1 ) {
if ( condición2 ) {
sentencia1;
} else {
sentencia2;
}
} else {
sentencia2;
}
Disyunción
if ( condición1 || condición2 ) {
sentencia1;
} else {
sentencia2;
}
if ( condición1 ){
sentencia1;
} else {
if ( condición2 ) {
sentencia1;
} else {
sentencia2;

10. }
}
Negación
if ( ! condición1) {
sentencia1;
} else {
sentencia2;
}
if ( condición1) {
sentencia2;
} else {
sentencia1;
}

11. Sentencia switch
Vamos a desarrollar una calculadora totalmente elemental. Sin muchas características salvo
de realizar operaciones aritméticas con dos operandos. Disponemos de una variable de tipo
char que nos indicará que tipo de operación se debe efectuar. Realizamos la operación y
mostramos el resultado en la pantalla. Después de luchar con las sentencias if-else nos quedó
algo parecido a esto:
public class MiniCalculadora {
public static void main(String args[]){
int a = 1;
int b = 1;
char op = '/';
System.out.print("El resultado es : ");
if ( op == '+' ) {
System.out.println( a + b);
} else if ( op == '-') {
System.out.println( a - b);
} else if ( op == '*') {
System.out.println( a * b);
} else if ( op == '/') {
System.out.println( a / b);
}
}
}
Ya nos alejamos bastante de las decisiones simples. Aquí tenemos de una cadena de
sentencias if-else que realizan un selección múltiple. La condición general tiene mas dos
alternativas. Tendremos que acudir a la sentencia switch que se encarga de este tipo de
selección.
public class MiniCalculadora{
public static void main(String args[]){
int a = 1;
int b = 1;
char op = '/';
System.out.print("El resultado es : ");
switch ( op ) {
case '+':
System.out.println( a + b );

12. break;
case '-':
System.out.println( a - b );
break;
case '*':
System.out.println( a * b );
break;
case '/':
System.out.println( a / b );
break;
default:
System.out.println("error" );
break;
}
}
}
La sentencia switch se encarga de estructurar una selección múltiple. Al contrario del
enunciado if-else que sólo podemos indicar dos alternativas, maneja un número finito de
posibilidades. La estructura general del enunciado switch es la siguiente:
switch( expresión ) {
case constante1:
sentencia1;
...
break;
...
case constanteN:
sentenciaN;
...
break;
default:
sentencia;
...
break
}

13. El valor de la expresión y de las constantes tiene que ser de tipo char, byte, short o int. No hay
lugar para booleanos, reales ni long porque, en la ejecución, todos los valores que
incorporamos se transforman en valores de tipo int.
Al evaluar la expresión de switch, el intérprete busca una constante con el mismo valor. Si la
encuentra, ejecuta las sentencias asociadas a esta constante hasta que tropiece con un break.
La sentencia break finaliza la ejecución de esta estructura. Si no encuentra ninguna constante
que coincida con la expresión, busca la línea default. Si existe, ejecuta las sentencias que le
siguen. La sentencia default es opcional.
Volviendo a la mini calculadora, vemos como se organiza las distintas alternativas de acuerdo
al valor de una constante char. Estas alternativas representan las distintas operaciones que
están disponibles y solo se ejecutará una sola. Por ejemplo, si el valor del operador (en el
programa figura op) es igual al signo de la suma , la sentencia switch ejecutará solamente la
línea que corresponde con esta operación.
¿Que ocurre si cambiamos la variable op por algún carácter distinto a los especificados? Entra
en juego la alternativa default y todas las setencias que le siguen. En este caso imprime por
pantalla el mensaje "error". Si nos olvidamos de incorporar esta alternativa, no pasa nada.
Ninguna sentencia dentro de la estructura switch se ejecutará.
Ya que hablamos de default, es conveniente mencionar que no es necesario que quede
relegado al final de la estructura. Podemos situarla al comienzo , en el medio, en definitiva, en
donde nos quede mas útil según la lógica que apliquemos o donde queramos.
switch ( op ) {
default :
System.out.println("error");
break;
case '+':
System.out.println( a + b );
break;
...
En el ejemplo presentado, funciona de la misma manera un default al principio. Obviamente no
debe existir mas de una alternativa default.
Las sentencias break son opcionales. Se utilizan con el propósito de separar las alternativas.
Pero fieles a nuestro estilo de meternos en problemas decidimos que algunos break deben
desaparecer. Probemos que ocurre con este código:
switch ( op ) {

14. case '+':
System.out.println( a + b );
case '-':
System.out.println( a - b );
break;
...
Es el mismo que el original, solo "olvidamos" de agregarle un break al final de la alternativa
suma. Si cambiamos el valor de op por el carácter '+' y ejecutamos el programa, nos responde
de esta manera:
El resultado es : 2
0
Nos dio los resultados de la suma y la resta. Al no tener un break en la suma, se pasó de largo
y ejecuto la de abajo , que justamente era la resta.
En algunas circunstancias, el break está de mas. Es posible contruir una estructura en donde
se ejecuten mas de una alternativa al mismo tiempo. Vemos un ejemplo:
public class Lineas{
public static void main(String args[]){
int j = 2;
switch (j) {
case 5:
System.out.println("********");
case 4:
System.out.println("********");
case 3:
System.out.println("********");
case 2:
System.out.println("********");
case 1:
System.out.println("********");
}
}
}

15. El programa tiene por objetivo listar un número dado de líneas. Se pueden dibujar hasta 5
líneas trazadas con el símbolo *. La cantidad dependerá del valor de la variable j. Por ejemplo,
si j vale 2, activa la alternativa que tiene esta constante y como no tiene un break que la
obstaculice sigue con la alternativa de abajo.
Sentencia while
La sentencia while es la más sencilla de las estructuras de iteración. La iteración continuará
hasta que su condición sea falsa.
while ( condición ) sentencia ;
La condición tiene que tomar un valor booleano (verdadero o falso). Si este valor es
verdadero, se ejecutará la sentencia. Concluida esta acción se vuelve a evaluar la condición.
Proseguirán los ciclos hasta que la condición no cambie a falso.
Esta es una estructura de iteración preprueba, es decir primero se evalúa la condición antes
de realizar cualquier acción. Si de entrada la condición es falsa nunca ejecutará el conjunto de
sentencias.
int n = 0;
while ( n > 0 ) System.out.println("Esto nunca lo verás");
Dentro del conjunto de sentencia en el que el supuesto o dicho controla, debe existir alguna
que cambie el valor de la condición que se está evaluando.
boolean prueba = true;
while ( prueba ) {
System.out.println("Esto lo verás una vez");
prueba = false;
}

16. Entraríamos en un ciclo infinito si nunca se modifica la condición y permanece verdadera.
boolean prueba = true;
while ( prueba ) {
System.out.println("Esto lo verás muchas veces");
}
Generalmente esta estructura se utiliza en situaciones en donde desconocemos la cantidad de
ciclos que se deben ejecutar para producir un resultado. Mostraremos como se utiliza en estas
circunstancias con el ejemplo de pase a binario, mostrado en el capítulo anterior.
Teníamos que transformar un número decimal a binario. El programa en java nos queda de
esta manera:
public class Dec2Bin{
public static void main(String args[]){
int decimal = 252222;
String binario = "";
while ( decimal > 0 ) {
binario = decimal % 2 + binario;
decimal /= 2;
}
System.out.println(binario);
}
}
Como no sabemos de antemano cuantas vueltas debe dar, simplemente esperamos que el
resultado de las divisiones sucesivas sea igual a cero.
También se pueden realizar ciclos con while en donde ya conocemos, antes de entrar en la
estructura, cuantas vueltas debe dar para terminar. Para esto nos auxiliamos con un contador
de vueltas. Previamente tiene que inicializarse antes de ingresar al ciclo. Luego en cada vuelta
se modificara según la lógica del algoritmo.
Realicemos el programa que despliegue por pantalla cinco líneas de caracteres.
public class Cuadrado{
public static void main(String args[]){
int contador = 1;
while ( contador <= 5 ) {
System.out.println("*****n");

17. contador++;
}
}
}
En este algoritmo, inicializamos el contador a 1 y luego en cada ciclo se incrementa. La
condición de corte tiene como objetivo no permitir mas vueltas si el contador superó el valor 5.
Para tener varias veces el asterisco sin necesidad de imprimirlo asi "*****", utilizamos otro ciclo
while y otra variable que inicializaremos dentro del ciclo para que se cumpla la cual
llamaremos "contador2", obtendremos el mismo resultado que el anterior, el codigo quedaria
asi:
public class Cuadrado
{
public static void main (String args [])
{
int contador = 1;
while (contador <= 5)
{
int contador2 = 1;
while (contador2 <= 5)
{
System.out.print ("*");
contador2++;
}
System.out.println ();
contador++;
}
}
}
(copian la parte que queda fuera del recuadro punteado al principio, y la llave que queda fuera
al final del mismo, lo pegan en ready to program y lo corren)

18. Sentencia do-while
La sentencia de iteración do-while es de tipo posprueba. Primero realiza las acciones luego
pregunta. La sintaxis es la siguiente:
do sentencia while ( condición );
Observamos que es como un while pero al revés. Primeramente se ejecuta la sentencia y
luego evalúa la condición. Si la expresión de la condición es verdadera vuelve a dar un ciclo.
De lo contrario, termina. Esto nos garantiza que la sentencia se ejecute al menos una vez.
do System.out.println("Lo veras una vez");
while ( false );
Resulta útil para los casos en donde tendremos que realizar ciertas acciones antes de verificar
una condición.
Realicemos un programa que cuente la cantidad de dígitos que posee un número. Para ello
tendremos que dividir por diez el número que nos han dado, hasta que el resultado se vuelva
cero. Entonces recurrimos al while para realice los ciclos necesarios.
public class CuentaDigitos{
public static void main(String args[]){
int número = 4557888;
int dígitos = 0;
while ( número > 0 ) {
número /=10;
dígitos++;
}
System.out.println(dígitos);
}
}
¿Qué ocurre si el número que nos dan es el cero? El resultado nos dará cero. Obviamente es
erróneo, debería devolver un dígito. Pero no entra en el ciclo debido a que de entrada no
satisface la condición. Podríamos implementar una solución "ad hoc".
número /=10;

19. dígitos++;
while ( número > 0 ) {
número /=10;
dígitos++;
}
public class CuentaDigitos{
public static void main(String args[]){
int número = 4557888;
int dígitos = 0;
do {
número /=10;
dígitos++;
}
while ( número > 0 );
System.out.println(dígitos);
}
}
Sentencia for
Trabajamos con casos de interacción en donde a priori no conocíamos la cantidad de ciclos
que se ejecutaban hasta cumplir con una condición. Para esto utilizamos la sentencia while.
Pero ahora estudiaremos con más detalle aquellos casos en donde se sabe de antemano
cuantos ciclos se deben cumplir para terminar la ejecución.
Imprimiremos una tabla de multiplicar hasta el factor noveno. Si no utilizamos ninguna
estructura de interacción, deberíamos imprimir nueve líneas de código secuencial.

20. System.out.println("3 x 1 = 3");
System.out.println("3 x 2 = 6");
System.out.println("3 x 3 = 9");
System.out.println("3 x 4 = 12");
System.out.println("3 x 5 = 15");
System.out.println("3 x 6 = 18");
System.out.println("3 x 7 = 21");
System.out.println("3 x 8 = 24");
System.out.println("3 x 9 = 27");
Pero ya conocemos las estructuras que nos ahorran el esfuerzo de escribir tanto código.
Utilizaremos una sentencia que ya conocemos: el while
int factor = 1;
while ( factor <= 9 ) {
System.out.println("3 x " + factor + " = " + 3*factor );
factor++;
}
Utilizamos la variable factor para contar la cantidad de líneas que imprimimos. Primeramente
la inicializamos en uno. Cuando se ejecuta la interacción se controla que no supere su valor
de 9. Si el valor es menor o igual que nueve, imprime una línea de la tabla e incrementa a uno
el valor de factor. Cualquier caso de interacción que se complete en una cantidad prefijada de
ciclos, necesitamos una variable de control. Si utilizamos la sentencia while, esta variable se
debe definir e inicializar antes del bucle y contar con una instrucción que modifique su valor
dentro del bucle.
Veremos como este código cambia ligeramente si en lugar de while presentamos una nueva
sentencia denominada for
for ( int factor = 1; factor <= 9; factor ++ ) {
System.out.println("3 x " + factor + " = " + 3*factor );
}
la sentencia for me permite repetir un ciclo n veces, en donde se debe determinar el valor
inicial y cuantas veces se repetira.
sintaxis
for({valor inicial};{condición de termino};{factor de incremento del
valor inicial}){
//acá va lo que se repetirá n veces de acuerdo a la condición de
termino

21. }
Bucle infinito: no hay control, entonces no se detiene
for ( ;;){}
Operador coma :
for ( int k=1, j=10 ;k < j ;k++ ,j-- ){
System.out.println(k + " " + j);
}
for mejorado
Supongamos que tenemos un arreglo de enteros que deseamos presentar en pantalla, usando
la orden for tradicional, el código, podría quedar así:
int[] laiEnteros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (int i = 0; i < 10; i ++)
System.out.println (laiEnteros[i]);
Java ofrece una funcionalidad extra para la orden for, mediante la que se puede simplificar
notablemente el codigo anterior, quedando así:
int[] laiEnteros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (int liElemento : laiEnteros)
System.out.println (liElemento);
En este caso, liElemento toma el valor de cada uno de los elementos de laiEnteros,
permitiendo una navegación más simple, puesto que se evitan posibles errores derivados del
uso de los arreglos en forma directa. También se puede usar esta forma, para estructuras más
complejas como objetos de la clase Collection
public void Presenta (Collection <Integer> poConjunto){
for (Iterator <Integer> loElemento : poConjunto)
System.out.println (loElemento)
}
Paquete Java

22. Un Paquete en Java es un contenedor de clases que permite agrupar las distintas partes de
un programa cuya funcionalidad tienen elementos comunes.
Ventajas
El uso de paquetes proporciona las siguientes ventajas:
 Agrupamiento de clases con características comunes.
 Reutilización de código.
 Mayor seguridad al existir niveles de acceso.
Contenido de un paquete
Un paquete puede contener:
 Clases
 Interfaces
 Tipos Enumerados
 Anotaciones
Uso de paquetes
En los ficheros de código Java se usa la palabra reservada package para especificar a qué
paquete pertenecen. Suele indicarse como primera sentencia:
package java.awt.event;
Para usar un paquete dentro del código se usa la declaración import . Si sólo se indica el
nombre del paquete:
import java.awt.event.*;
se importan todas las clases que contiene. Si además del nombre del paquete se especifica
una clase, sólo se importa esa clase:
import java.awt.event.ActionEvent;

23. Después de añadir alguna de estas sentencias, se puede hacer referencia a la
clase ActionEvent usando su nombre:
ActionEvent myEvent = new ActionEvent();
Si no se hubiera importado la clase o el paquete, cada vez que tuviéramos que usarla habría
que especificarlo:
java.awt.event.ActionEvent myEvent = new java.awt.event.ActionEvent();
Paquetes importantes de Java
Estos son los paquetes más importantes de la API de Java:
Paquete Descripción
java.applet Contiene clases para la creación de applets.
java.awt Contiene clases para crear interfaces de usuario con ventanas.
java.io Contiene clases para manejar la entrada/salida.
java.lang Contiene clases variadas pero imprescindibles para el lenguaje,
como Object, Thread, Math...
java.net Contiene clases para soportar aplicaciones que acceden a redes TCP/IP.
java.util Contiene clases que permiten el acceso a recursos del sistema, etc.
javax.swing Contiene clases para crear interfaces de usuario mejorando la AWT.
BIBLIOGRAFIA:https://es.wikipedia.org/wiki/Paquete_Java
http://es.slideshare.net/alfasixx2498/comandos-de-java

24. https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java/Sentencia_if-else