programacion visual con java 3

UNIVERSIDAD NACIONAL DEL SANTA

FACULTAD DE INGENIERIA

E.A.P INGENIERIA DE SISTEMAS E INFORMATICA

MANUAL DE PROGRAMACION VISUAL CON JAVA

PARTE - 3

Ing. Mirko Manrique Ronceros

Primera Edición

Universidad Nacional del SantaFacultad de Ingeniería Programación Visual con JavaE.A.P. Sistemas e Informática

INTERFASES MULTIMEDIA Y MANEJO DE PAQUETES

Uso de paquetes

En Java, es posible agrupar varias clases en una estructura llamada paquete. Un

paquete no es más que un conjunto de clases, generalmente relacionadas entre sí de

alguna manera. Es habitual diseñar una aplicación distribuyendo su funcionalidad

entre varios paquetes, cuyas clases se comunican entre sí a través de interfaces bien

definidas.

El uso de paquetes aporta varias ventajas frente a la programación sin paquetes. En

primer lugar, permite encapsular funcionalidad en unidades con un cierto grado de

independencia, ocultando los detalles de implementación. De esta forma se pueden

conseguir diseños (e implementaciones) más limpios y elegantes.

Por otra parte, se potencia la reutilización de las clases desarrolladas. Es posible

definir interfaces de uso de cada paquete, para que otros paquetes o aplicaciones

puedan utilizar la funcionalidad implementada. Además, el uso de paquetes permite la

reutilización de los nombres de las clases, ya que el espacio de nombres de un

paquete es independiente del de otros paquetes. El lenguage Java impone la

restricción de que una clase debe tener un nombre único, dentro del paquete al cual

pertenece. Sin embargo, es posible que dos clases tengan el mismo nombre, siempre

y cuando pertenezcan a paquetes distintos.

Para incluir una clase dentro de un paquete, únicamente hay que utilizar una

sentencia package al principio del fichero fuente.

Por ejemplo:

package prueba;

public class Prueba

{

...

}

o con subpaquetes:

package prueba.prueba2;

public class Prueba

Ing. Mirko Manrique Ronceros Página 3


{

...

}

El nombre completo de la clase (fully qualified name) está compuesto por el nombre

del paquete al cual pertenece la clase además del nombre de la propia clase.

Los nombres completos de las clases del ejemplo anterior son prueba.Prueba y

prueba.prueba2.Prueba.

Dado que prueba y prueba.prueba2 son paquetes distintos (aunque prueba.prueba2

sea un subpaquete de prueba), no hay colisión de nombres entre prueba.Prueba y

prueba.prueba2.Prueba. Sin embargo, aunque el compilador permita usar el mismo

nombre de esta forma, no es una práctica aconsejable porque el código tiende a ser

confuso y propenso a errores.

En cuanto al nombre de los paquetes, Sun propuso en su momento un convenio para

facilitar el uso de paquetes de terceros. Este convenio no es en absoluto obligatorio,

aunque sí es aconsejable seguir alguno, o bien éste o bien otro, para mantener

mínimamente organizadas nuestras clases.

Para usar clases de otros paquetes, no hay más que utilizar sentencias import, antes

de la declaración de la clase.

Por ejemplo:

import java.lang.*;

import java.util.Vector;

import java.rmi.server.*;

Con el primer import le estamos indicando al compilador que vamos a importar todas

las clases del subpaquete java.lang. (Este paquete contiene clases esenciales en la

mayoría de aplicaciones Java, por lo que el compilador lo importa automáticamente,

aunque no incluyamos una línea como la de arriba). Con el segundo import, indicamos

que sólo queremos importar la clase Vector del subpaquete java.util. Con el tercer

import, importamos todas las clases del paquete java.rmi.server.

Es posible utilizar una clase sin que esté incluída en un import, siempre y cuando

utilicemos su nombre completo.

Por ejemplo:

java.util.Vector vector = new java.util.Vector(100, 10);



La ventaja de utilizar una sentencia import es que la anterior línea se puede reducir a

Vector vector = new Vector(100, 10);

Java Media Framework

The Java Media Framework (JMF) is a recent API for Java dealing with real-time multi-

media presentation and effects processing. JMF handles time-based media, media

which changes with respect to time. Examples of this are video from a television

source, audio from a raw-audio format file and animations. The beta JMF 2.0 specific-

ation will be used for this report, as they currently reflect the features that will appear

in the final version.El Java Media Framework (JMF) es una API para Java últimos se

ocupan de multimedia en tiempo real la presentación y procesamiento de efectos. JMF

se ocupa de los medios de comunicación basados en el tiempo, los medios de

comunicación que cambia con respecto al tiempo. Ejemplos de esto son el vídeo de

una fuente de televisión, audio de formato de archivos de audio y animaciones.

Java Media Framework proporciona a los applets y aplicaciones Java la capacidad de

reproducir capturar y transmitir/recibir en tiempo real video y otros contendios

multimedia. Provee de una serie de codificadores y decodificadores para los formatos

multimedia más relevantes siendo capaz además, de realizar transcodificación entre

dichos formatos.

Etapas



JMF La arquitectura está organizada en tres etapas:

Durante la etapa de entrada, se lee los datos de una fuente y se aprueban en buffers

a la etapa de procesamiento. La etapa de entrada puede consistir en la lectura de

datos desde un dispositivo de captura (como una cámara web o tarjeta de captura de

TV), un archivo en el disco o arroyo De la red.

La etapa de procesamiento consiste en una serie de codecs y efectos diseñados para

modificar el flujo de datos a uno adecuado para la producción. Estos codecs podrán

ejercer funciones como comprimir o descomprimir el audio a un formato diferente, la

adición de una marca de agua de algún tipo, la limpieza de ruido o aplicar un efecto

de la corriente (como eco a los de audio).

Una vez que la etapa de procesamiento se ha aplicado sus transformaciones a la

corriente, pasa la información a la etapa de salida. La fase de salida puede tomar la

corriente y pasarlo a un archivo en el disco, la producción local a la pantalla de vídeo

o transmitirlo a través de la red .

Por ejemplo, un sistema de JMF puede leer el aporte de una tarjeta de captura de TV

local el sistema de captación de los aportes de una grabadora en la etapa de entrada.

Puede entonces pasar a la fase de transformación, para añadir una marca de agua en

la esquina de cada cuadro y, por último, emisión A través de la Intranet local en la

etapa final.



Componente de Arquitectura

JMF es construido alrededor de una arquitectura de componentes. El compenents se

organizan en una serie de categorías principales:

• Medios manipuladores

• Fuente de los datos

• Codecs / Efectos

• Extracción de grasas

• Mux / Demuxes

Medios Manipuladores

MediaHandlers están registradas para cada tipo de archivo que JMF debe ser capaz de

manejar. Para apoyar nuevos formatos de archivo, un nuevo MediaHandler se pueden

crear.

RenderersExtracción de grasas

Un procesador es similar a un Codec, pero la final está en un lugar diferente al otro

arroyo. VideoRenderer Un salidas los datos finales a la pantalla, sino otro tipo de

procesador podría salida a los diferentes equipos, como por ejemplo una tarjeta de

salida de TV.

Mux/DemuxesMux / Demuxes

Multiplexores y Demultiplexers se utilizan para combinar múltiples arroyos en una sola

corriente o viceversa, respectivamente. Son útiles para crear y leer un paquete de

audio y video para guardarse en el disco como un solo archivo, o se transmite a través

de una red.



Aplicación multimedia

Presenting Data

Una aplicación multimedia es aquella que produce, reproduce, procesa o maneja uno

o varios contenidos multimedia. A su vez un contenido multimedia es aquel que está

compuesto de diversos “medios”, como pueden ser audio, video, texto, etc. Decimos

que un contenido multimedia está basado en el tiempo en tanto que cada uno de sus

medios cambia significativamente con él. Esta característica hace que un contenido

multimedia requiera ser proporcionado y procesado en unas condiciones temporales

estrictas. Por ejemplo cuando se reproduce un video, si los datos multimedia no

pueden ser proporcionados lo suficientemente rápido pueden producirse pausas y

retardos en la reproducción; por otro lado si los datos no pueden ser recibidos y

procesados lo suficientemente rápido el video se reproduce a saltos en tanto que se

desechan cuadros como medio para mantener la tasa de reproducción.

Cada uno de los medios de los que se compone un contenido multimedia se denomina

pista . Por ejemplo un contenido multimedia correspondiente a una videoconferencia

puede contener una pista de audio y otra de video. Se dice que las pistas que

componen un contenido multimedia están multiplexadas, al proceso de extracción de

las distintas pistas que componen un contenido multimedia se le denomina

demultiplexación. Existen distintos tipos de pistas en función del tipo de datos que

contienen, como audio y/o video; a su vez cada pista posee un formato que define

como están estructurados los datos que forman parte de ella. Los distintos formatos

se distinguen en función de:

• La calidad que proporcionan

• Su exigencia de recursos de CPU para ser procesados.

• La cantidad de ancho de banda requerida para su transmisión.

En Java Media Framework los datos multimedia pueden proceder de diversas

fuentes, como archivos locales o remotos y video y audio en tiempo real o bajo

demanda.

Una fuente de datos multimedia se modela mediante un objeto DataSource. Podemos

crear una DataSource directamente a través de una URL (Universal Resource Locator)

o bien mediante un objeto de tipo MediaLocator.

Vamos a proceder a ejecutar un audio, para ello necesitamos un arhivo de formato

mp3, como por ejemplo mana.mp3. Para lograr esto sigamos los siguientes pasos:



1. Instalamos el Java Media Framework, que lo encontramos en la siguiente

dirección:

http://java.sun.com/products/java-media/jmf/2.1.1/download.html

En ésta dirección tienes la opción de descargar el instalador de Java Media

Framework indicando la plataforma que pueder ser windows, linux, etc.

Aproximadamente en la plataforma Windows es de 4.8Mb el tamaño del

instalador.

2. Vamos al entorno de NetBeans y creamos un proyecto llamado

PruebaMultimedia.

La localización del proyecto se encuentra en la unidad D:\

Luego dar click en el botón de comando Finish (en caso de que la versión de

NetBeans es en castellano entonces dar click en el botón de comando

Terminar)

3. Procedemos a crear un archivo class denominado Applet_Reproductor.

Ubicamos el puntero del mouse sobre el paquete pruebamultimedia y al dar

click botón derecho del mouse y se muestra un menú flotante donde

seleccionamos Java Class.


http://java.sun.com/products/java-media/jmf/2.1.1/download.html


4. Indicamos como nombre de clase Applet_Reproductor.





Terminar)

5. Estando en el entorno de NetBeans borramos lo que observamos seleccionado:

6. En el lugar donde se borró se colocará el siguiente código de programación:

import java.awt.*;

import java.applet.*;

import java.lang.String;

import java.net.URL;

import java.net.MalformedURLException;

import java.io.IOException;

import javax.media.*;

public class Applet_Reproductor extends Applet implements ControllerListener{

String MEDIAFILE = "mana.mp3";

//Reproductor

Player player=null;



//Componente de reproducción del vídeo

Component visualComponent=null;

//Controles

Component controlComponent=null;

//Barra de progreso

Component progressBar=null;

/**

*Permite seleccionar el archivo a reproducir y crea el reproductor

*/

public void init() {

setLayout(new BorderLayout());

//URL base del documento HTML

URL codeBase = getDocumentBase();

URL url = null;

try{

//Se crea URL para el archivo

if ((url = new URL(codeBase,MEDIAFILE)) == null)

System.err.println("No se puede construir URL para el archivo");

//Se crea el reproductor

player=Manager.createPlayer(url);

player.addControllerListener(this);

}

catch (MalformedURLException e){

System.err.println("URL no valida");

}

catch (IOException e){

System.err.println("Excepcion de Lectura/Escritura");

}

catch (NoPlayerException e){

System.err.println("No existe reproductor");

}

}

/**



*Comienza la reproducción del archivo

*/

public void start(){

if (player != null) player.start();

}

/**

*Detiene la reproducción y libera recursos

*/

public void stop(){

if (player != null){

player.stop();

player.deallocate();

}

}

/**

*De acuerdo al interfaz ControllerListener. Llamada cuando ocurre algun

*evento en la reproduccion

*/

public synchronized void controllerUpdate(ControllerEvent event){

//Comprobamos que el reproductor está "vivo"

if (player == null) return;

//Qué evento se ha producido?

if (event instanceof RealizeCompleteEvent){

//Se añade el componente de visualización del reproductor y el de control

if((visualComponent = player.getVisualComponent()) != null)

add("Center",visualComponent);

if ((controlComponent = player.getControlPanelComponent()) != null)

add("South",controlComponent);

validate();

}

else if (event instanceof EndOfMediaEvent){

player.setMediaTime(new Time(0));

player.start();



}

else if (event instanceof ControllerErrorEvent){

player = null;

System.err.println(((ControllerErrorEvent)event).getMessage());

}

}

public void paint(Graphics g) {

}

}

7. Compilamos el archivo.

8. Luego procedemos a ejecutarlo.



Se muestra errores de ejecución debido a que no encuentra el archivo

mana.mp3 dentro del proyecto PruebaMultimedia.

9. Debemos tener en cuenta que el archivo mana.mp3 debe quedar ubicado

dentro de la carpeta build del proyecto PruebaMultimedia para que la aplicación

se ejecute normalmente.

10. Procedemos nuevamente a ejecutarlo y se observa la siguiente ventana e

inmediatamente se ejecuta el audio.



MANEJO DE LOS SWING WINDOWSObjeto JDialog y JFrame

JDialog es un componente que sirve para presentar diálogos que son ventanas

auxiliares que se presentan cuando se registra un evento dentro de un programa,

sirven para prevención o en su defecto se puede utilizar para dar información sobre

algo, los diálogos que JDialog muestra pueden ser modales o no modales, esto quiere

decir que si son modales la ventana del diálogo bloquea las entradas a otras ventanas,

este tipo de diálogos se pueden hacer también con JoptionPane.

Todos los diálogos dependen de un frame, las modificaciones que se le hagan al frame

afectaran a el diálogo, en caso de que el frame sea cerrado, minizado o maximizado,

sus diálogos tendrán el mismo comportamiento.

Un objeto JFrame es una ventana más utilizado para diseñar formularios. Vamos a

proceder hacer comparaciones con el objeto JDialog:

• Si instanciamos un JFrame en la barra de abajo de windows (creo que se llama

"barra de herramientas") nos aparece un nuevo "botoncito" correspondiente a

nuestra aplicación. Si instanciamos un JDialog, no aparece nada.

• Un JFrame tiene un método setIconImage() para cambiar el icono por

defecto de la taza de café. JDialog no tiene este método.

• Un JDialog admite otra ventana (JFrame o JDialog) como padre en el

constructor. JFrame no admite padres.

• Un JDialog puede ser modal, un JFrame no.

Todo esto nos indica lo siguiente:

• Un JFrame debe ser la ventana principal de nuestra aplicación y sólo debe

haber una.

• Las ventanas secundarias de nuestra aplicación deben ser JDialog.

Los motivos de esto son los siguientes:

Al mostrar el JFrame un botón en la barra de herramientas de windows y tener

método para cambiar el icono, es la ventana ideal como ventana principal de nuestra



aplicación y sólo debe haber una. Nos permite cambiar el icono y sólo debe haber un

botón en la barra de herramientas de windows para nuestra aplicación.

Si usamos un JDialog como ventana principal, no tenemos botón en la barra de

herramientas y no hay forma fácil de cambiarle el icono.

Los JDialog son ideales para ventanas secundarias porque admiten una ventana

padre. Si la VentanaA es padre del JDialogB, entonces el JDialogB siempre estará por

delante de VentanaA, nunca quedará por detrás. Lo ideal es que hagamos nuestras

ventanas secundarias como JDialog cuyo padre sea el JFrame principal. De esta

forma los JDialog siempre serán visibles por encima del JFrame y no se irán detrás

ni quedarán ocultos por el JFrame.

Otra ventaja de admitir un padre es que heredan el icono de él. Si hemos cambiado el

icono del JFrame con el método setIconImage(), entonces todos los JDialog que

hagamos como hijos de este JFrame heredarán el icono. Todas las ventanas de

nuestra aplicación tendrán el mismo icono en lugar de la taza de café por defecto.

Un JDialog puede ser modal, pasándole un true en el constructor en el sitio

adecuado o haciéndolo modal con el método setModal(). Si hacemos un JDialog

modal, todas las demás ventanas se deshabilitarán hasta que el usuario de nuestro

programa cierre el JDialog. Esto está estupendo para pedir un dato al usuario y evitar

que toque otras cosas hasta que haya introducido el dato. Sin embargo, tiene un

peligro.

Supongamos un JDialog que lo hacemos modal para pedir unos datos al usuario. Este

JDialog tiene un botón de "Aceptar" para que el usuario lo pulse cuando haya

terminado de introducir los datos. Supongamos que en el código de ese botón

"Aceptar" comprobamos los datos que ha metido el usuario y vemos que son

incorrectos. Le sacamos un segundo JDialog modal para indicarle el error y no

cerramos el primero.

¿Quién debe ser el padre de ese segundo JDialog modal?. Si hacemos que el padre

sea el JFrame tendremos dos JDialog modales hijos del JFrame, es decir, dos

JDialog modales hermanos. Esto nos dará problemas, como que ambas ventanas

queden deshabilitadas, que al cerrar una de ellas se nos oculten todas, que parte de la

ventana quede deshabilitada mientras que otra parte no, etc.



Entonces, ¿cómo hacemos?. Para que java no haga cosas raras, el padre del segundo

JDialog modal debe ser el primer JDialog modal. De esta forma, el segundo tiene

"prioridad" sobre el primero. Todo queda deshabilitado excepto este segundo JDialog.

Cuando lo cerremos, será el primero el que mande. Si queremos varias ventanas

modales simultáneamente en pantalla, cada ventana que se muestre debe ser padre

de la siguiente, de forma que la cadena de ventanas modales sean padre, hijo, nieto,

etc. Tener dos ventanas modales simultaneas que sean hermanas o primas o cualquier

otra relación que no sea directa, nos dará problemas

Aplicación 1

Vamos a proceder a crear un formulario donde se hará uso del objeto JDialog para

mostrar un mensaje dentro de un objeto de control JtextArea.

Solución:

1. Procedemos a crear un proyecto denominado SwingWindows.





Terminar)

2. Estando en el entorno de NetBeans, seleccionamos el paquete swingwindows

y dando click botón derecho del mouse, se muestra un menú flotante, donde

seleccionamos Formulario Jframe.

3. A continuación, colocaremos como nombre de formulario frmUsoJDialog.



4. Procedemos a programar

package swingwindows;

import javax.swing.*;

import java.awt.*;

public class frmUsoJDialog extends javax.swing.JFrame {

/** Creates new form frmUsoJDialog */

public frmUsoJDialog() {

initComponents();

// creamos una variable del tipo JDialog

JDialog dialog;

// creamos una variable de tipo JFrame

JFrame credi;

credi=new JFrame();

dialog = new JDialog(credi, "", true);

dialog.setTitle("Creditos");

JTextArea texto = new JTextArea("Este Programa fue Diseñado por :\n" +

"Martín Salcedo Quiñones\n" + "Como Trabajo del curso de Programación

Visual\n" +"Contiene jFrame y JDialog\n");

Container contentPane = dialog.getContentPane();

contentPane.add(texto, BorderLayout.CENTER);

dialog.setSize(new Dimension(300, 150));

dialog.show();

}

En la línea de programación siguiente:

dialog = new JDialog(credi, "", true);

Podemos notar la parte del String está vacía, esto se debe a que en el

programa vamos a cambiarle el título al JDialog, a medida que necesitemos

presentar uno nuevo, esto con el fin de crear un solo JDialog para las diferentes

ventanas. También vemos que en boolean esta true esto es para especificar que

es un diálogo modal en caso que no lo pondríamos false.



En la línea de programación siguiente:

dialog.setTitle("Creditos");

El método setTitle es utilizada para cambiarle el título a dialog.

En las líneas de programación siguiente:

JTextArea texto = new JTextArea("Este Programa fue Diseñado por :\n" +

"Martín Salcedo Quiñones\n" + "Como Trabajo del curso de Programación

Visual\n" +"Contiene jFrame y JDialog\n");


Creamos el componente que va dentro, y a continuación se pone el dialog

dentro del contentPane junto con el componente.

En las líneas de programación siguiente:


dialog.show();

Por último se dice el tamaño del JDialog y la última línea es para que sea

mostrado.

5. Procedemos a compilar el formulario frmUsoDialog y luego ejecutarlo.

6. Una vez ejecutado se mostrará la ventana:



Objeto JFileChooser

En Java tenemos varias formas para leer y escribir ficheros de textos, binarios, de

formato xml, etc. La clase JFileChooser permite mostrar una ventana para que el

usuario nevegue por los directorios y elija un archivo.

Para pedir un archivo para abrirlo y leerlo basta hacer dos líneas de programación:

JFileChooser fileChooser = new JfileChooser();

int seleccion = fileChooser.showOpenDialog(areatexto);

Este código abre una ventana para navegar en directorios y eligir un fichero.

Pocremos selecionar el botón de comando Abrir o el botón de comando Cancelar. En

la variable de memoria seleccion se almacenará el valor del botón de comando

seleccionado. Sólo debemos comprobar si es el botón de comando Abrir para pedirle

a JFileChooser qué archivo ha elegido el usuario y empezar a trabajar con él.

If (selección ==JfileChooser.APPROVE_OPTION)

{

File fichero = fileChooser.getSelectedFile();

}



Si selección vale JFileChooser.APPROVE_OPTION es que el usuario ha pulsado

“Abrir”, así que pedimos el fichero seleccionado con getSelectedFile().

JFileChooser abre una ventana que se mostrará junto a la ventana de nuestro editor.

Nos gustaría que esta ventana de selección de fichero no se vaya detrás y quede

oculta por la ventana del editor. La ventana de elegir fichero debería estar siempre

delante y visible sobre el editor. La forma de conseguir esto es que JFileChooser

sepa cual es esta ventana delante de la cual debe estar siempre. Para saber cual es

esa ventana, basta con pasarle en el parámetro cualquier componente de dicha

ventana. En nuestro ejemplo hemos decidido pasarle el JTextArea de nuestro editor,

pero podíamos pasarle perfectamente el JMenuBar o el JFrame principal.

Para elegir un fichero para salvar, el código es exactamente igual, pero cambia el

método para visualizar el diálogo.

JFileChooser fileChooser = new JFileChooser();

int seleccion = fileChooser.showSaveDialog(areatexto);

Aplicación 2

Vamos a proceder a crear una aplicación donde usaremos el JFrame,JDialog,

JTextArea, y JFileChooser para hacer lectura de un archivo texto seleccionado y

abierto desde un JFileChooser.

Solución:

1. Procedemos a crear un proyecto denominado PruebaJFileChooser.



Terminar).



2. Todo proyecto creado crea por defecto un archivo main de extensión java.

Haremos uso de este archivo para lo cual colocaremos el siguiente código.

package pruebajfilechooser;

import javax.swing.*;

import java.io.*;

import java.awt.*;

/**

*

* @author Usuario

*/

public class Main {

/** Creates a new instance of Main */

public Main() {

}

/**

* @param args the command line arguments

*/

public static void main(String[] args)throws IOException {

JTextArea area= new JTextArea();

JDialog dialog;

JFrame formulario = new JFrame();

dialog = new JDialog(formulario, "", true);

dialog.setTitle("Mostrar Archivo");

//se instancia la variable fileChooser del tipo JFileChooser

JFileChooser fileChooser = new JFileChooser();

//con el método showOpenDialog() se muestra la ventana para seleccionar el

archivo

int seleccion = fileChooser.showOpenDialog(area);

//si el usuario selecciona el botón de comando Abrir, el if se hace verdadero

if (seleccion==JFileChooser.APPROVE_OPTION)

{



//la variable fichero contiene el archivo texto seleccionado con el método

getSelectedFile()

File fichero = fileChooser.getSelectedFile();

//la variable reader permite leer linea por linea el archivo a través del

método readLine()

BufferedReader reader = new BufferedReader(new FileReader(fichero));

String linea = reader.readLine();

//con while se lee línea por línea y se pasa a la variable area que es un

JTextArea

while (linea != null)

{

area.append(linea);

area.append(System.getProperty("line.separator"));

linea = reader.readLine();

}

//se cierra el fichero

reader.close();

//se muestra visualmente el contenido de la variable area dentro de un JDialog


contentPane.add(area, BorderLayout.CENTER);


dialog.show();

}

}

}

3. Una vez compilado, procedemos a ejecutarlo.



4. Observamos la ventana generada por el objeto JfileChooser.

Seleccionamos el archivo texto Grupos para Procedimientos Almacenados ...,

luego damos click en el botón de comando Abrir. A continuación, visualizamos la

siguiente interface:


programacion visual con java 3

Documents

import java

dado que prueba y prueba

subpaquete java

new java

java parte

paquetesen java

es ms que

los paquetes