Ricardo Daniel Arteaga Nava3° Am

Diseña Software de Aplicación Utilizando Programación Orientada a

Objetos M.C.A Margarita Romero Alvarado

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:\users\afq\classes\;C:\jdk\classes 

-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.main(), lo que aparecería en esta entrada 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 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.

-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=green ...

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.

SentenciasSentencia 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 :

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[]){ 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;} 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 ) { 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;}}

Negación

if ( ! condición1) {sentencia1;} else {sentencia2;}

if ( condición1) {sentencia2;} else {sentencia1;}

Sentencia switchVamos 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 ); 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 }

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 ) { 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("********"); } } }

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 whileLa 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; }

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"); 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)

Sentencia do-whileLa 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; 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 forTrabajamos 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.

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}

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 mejoradoSupongamos 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 JavaUn 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 paqueteUn paquete puede contener:

Clases

Interfaces

Tipos Enumerados

Anotaciones

Uso de paquetesEn 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;

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 JavaEstos 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

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