2.1: Definición conceptual de componentes, paquetes/librerías.

Componente. Un componente es el elemento básico de una interfaz gráfica. Los

componentes permiten al usuario interactuar con la aplicación y proporcionar
información desde el programa al usuario sobre el estado de la aplicación.
Ejemplos de componentes son: los botones, las barras de desplazamiento, las
etiquetas, las listas, las cajas de selección o los campos de texto, entre otros.
Cabe mencionar que los componentes nunca se encuentran de forma aislada, sino
agrupados dentro de contenedores. Los contenedores contienen y organizan la
situación de los componentes; además, son en sí mismos componentes y como
tales pueden ser situados dentro de otros contenedores.
Ejemplos de componentes:
-Botones
Barras de desplazamiento
-Etiquetas
-Listas
-Cajas de selección o los campos de texto

Paquetes: Los paquetes en Java son una manera de organizar nuestras clases,

ya sea por finalidad, por su relación con la herencia que tienen, etc. 
Pasos para crear o utilizar paquetes (package): 
1. Crear una carpeta – paquete. 
2. Mover y/o almacenar las clases que solucionan el problema. 
3. A cada una de las clases, se les agrega la palabra reservada “package” de la
siguiente forma: package NombreDeLaCarpeta; 
4. Las clases deben llevar el modificador “public”, por ejemplo: public class
Numero. 
5. A las clases que utilicen las clases enpaquetadas, se les indica la ruta de las
clases correspondientes, ocupando la palabra reservada “import”. import
NombreDeLaCarpeta.*;

Librerías: La utilización de objetos dinámicos supone dejar pendiente en el

montaje de la aplicación el enlace de dichos objetos. Cuando la aplicación está en
ejecución, y sólo entonces, se produce el enlace (dinámico) con los objetos
contenidos en la librería. La creación de librerías dinámicas corre a cargo del
enlazador o montador (en nuestro caso el ld) aunque también es posible indicar al
compilador las opciones necesarias para el montaje y de ese modo, será él quien
se encargue de pasárselas al montador. Cuando se crea un objeto dinámico es
necesario que dicho código objeto sea independiente de la posición, para
conseguir este tipo de código debe especificarse al compilador la opción -fPIC
(Position IndependentCode). Dicho flag debe indicarse tanto en la compilación
como en el montaje de la librería. Para montar los objetos es necesario además
indicar la opción -shared para que el resultado sea un fichero objeto ‘compartible’.
2.2 USO DE LIBRERÍAS PROPORCIONADAS POR EL LENGUAJE

Java es un lenguaje de programación desarrollado para una multitud de

plataformas y procesadores.

Consideremos los dos tipos de aplicaciones gráficas más comunes.

Modelos de Frames y Applets, se pueden construir usando cualquiera de las dos

galerías de componentes visuales, son:

JAVA AWT: Es la librería visual más antigua de java usando esta librería, se
podrán construir los tres tipos de programas mas comunes como son FRAME,
WINDOW y APPLET.

JAVA SWING: Es la librería de componentes visuales más nueva que proporciona

java, usando esta librería se podrán construir los tres tipos de programas o
aplicaciones que son JFRAME,WINDOW Y JAPPLET.

Un applet es un programa en java que se mandan a una máquina o PC remota

para que los ejecuten o lo corra, cuando este applet de llegada a las máquinas
remotas vía browser, dicho browser es quien activa la máquina virtual de java que
da la orden de compilación y ejecución, es decir java programa.applet.

Entonces es importante que la máquina virtual de java, que se encuentra en la PC

remota,tenga capacidad de incluir todas las librerías de java, como la de match, la
de AWT, la de lang.etc.

Existen diferentes librerías en java, entre las cuales se encuentra.

Java. lang

Colección de tipo básico siempre importados a cualquier unidad de compilación.

Aquí están las declaraciones de objetos, clases, wrappers.

Interfaces Clases.

Cloneables Boolean
Comparable Byte

Runnable Character

ClassLoader

Compiler

Double

Float

InheritableThreadLocal

Interger

Long

Math

Number

Object

System

Thread

Void String, etc..

Java.io

Archivos de stream y acceso aleatorio. Librería estándar de entrada y salida.

Interfaces Clases

DataInput BufferedInputStream

DataOutput BufferedOutputStream

Externalizable BufferedReader

Filefilter Bufferedwrite

FilenameFilter ByteArrayInputStream
OdjectInput ByteArrayOutputStream

Serializable DataOutputStream

File

InputStream reader

Writer,etc..

Java.net

Librería que apoya interfaces con telnet y URL.

Interfaces Clases

ContentHandlerFactory Authenticator

DatagramSocketImplFactory ContentHandler

FileNameMap DatagramPacket

SocketOptions DatagramSocketImpl

URLStreamHanlerFactory HttpURKConnection URL, etc..

Java.util

Clase como de diccionarios, tabla de hash, stack, técnica de codificación hora,

fecha, etc.

Interfaces Clases

Collection AdstractCollection

Comparator AdstracList

Enumeration AdstrectMap

EventListener AdstrectSecquentialList

Interator AdstractSet

List ArreyList
Observer Collection

SortedSet EventObject

Random Stack

Timer

Vector

Date,etc.

Java.Awt

Abstract Windowing Toolkit que proporciona una capa abstracta que permita llevar
una aplicación en java de un sistema de ventanas a otro. Contiene clases para
componentes básicos de la interfaz, tales como eventos, colores, tipos de letra,
botones, campos de texto.

Estructura del awt.

La estructura de la versión actual del AWT en la plataforma Java 2 se puede

resumir en los puntos siguientes:

Los contenedores contienen componentes, que son los controládores básicos.

No se usan posiciones fijas de los componentes, si no estan situados a traves de

una disposición controlado (layouts)

El común denominador de más bajo nivel se acerca al teclado, ratón y manejo de

eventos.

Alto nivel de abstracción respecto al entorno de ventanas en que se ejecute la

aplicación (no hay áreas clientes, ni llamadas a X ).

La arquitectura de la aplicación es dependiente del entorno de ventanas, en vez

de tener un tamaño fijo.

Carece de un formato de recursos. No se puede separar el código de lo que es

propiamente interfaz. No hay ningún diseñador de interfaz toda vía.
Interfaces Clases

ActiveEvent AlphaComposite

Adjustable AWTEvent

Java.applet

El paquete java.applet permite la creación de applets atraves de la clase Applet,

proporciona interfaces para conectar un applet a un documento web y para
audición de audio.

Interfaces Clases

AppletContext Applet

AppletStub

AudiClip

Java.math

Proporciona cálculos en entero grande y real grande.

Clases

Bigdecimal

Biginteger

Además de la clase Math.

Esta es la clase que representa la librería matemática de Java. Las funciones que
contiene son las de todos los lenguajes, parece que se han metido en una clase
solamente a propósito de agrupación, por eso se encapsulan en Math, y lo mismo
sucede con las demás clases que corresponde a objetos que tiene un tipo
equivalente(carácter, Float, etc.)

La clase Math es public para que se pueda llamar desde cualquier sitio y static
para que no haya que iniciarla.

Java.rmi
Este paquete hace posible que un objeto se ejecute en una maquina virtual Java
invoque métodos de otro objeto que se ejecuta en la máquina virtual distinta; dicha
máquina virtual pueden encontrarse en ordenadores diferentes conectados a
través de una red TCP/IP.

Interfaces Clases

Rmote MarshalledObject

Naming

RMISecurityManager

Java.text

Contiene clase que permiten dar formato especializado a fechas, números y

mensajes.

Interfaces Clases

AttributedChacterIterator Annotation

CharacterIterator AttibutedCharacterIterator

ChoceFormat

DateFormat

Format

MessageFormat

NumberFormat

ParsePosition

Java.sound.midi

Paquete con clase e interfaces que permitan la captura, procesamiento y

reproducción de música MIDI.

Interfaces Clases
ControllerEventListener Instrument

MataEventListener MeteMessage

MidiChannel MidiDevice.info

MidiDevice MidiEvent

Receiver MidiFileFormat

Sequecer Midemessage

JAVA .SQL

Junto con el paquete javax.sql, incluido en java 2 SDK Edición para la empresa,
forma parte del API de java 2.0 (conexión Java a Base de Datos), y permite la
conexión de base de datos, el envió de sentencias SQL y la interpretación de los
resultados de las consultas.

Intefaces Clases

Array Date

Blob DriverManager

CallabeStatement DriverPropertyInfo

Clob SQLPermission

Connecction Timer

DatabaseMetaDate Timestamp

Driver Type

Ref

SQLData

SQLInput

SQLOutput

Struct
JAVA.SWING

Paquete que mejora e AWT, proporcionando un conjunto de componentes que se

ejecutan de manera uniforme en todas las plataformas.

Interfaces Clases

Action AbstractAction

ComboBoxEditor ActonMap

Icon Box.Filler

ListModel CellRendererPane

MenuElement DebugGraphics

WindowsConstants DefaulListSelectionModel

JApplet

Jbutton

JCheckBox

JFrame JMenu

JLabel

JPanel

JTextField

JTree

JWindows

Temer

UIManager, etc..
2.3 Creación de componentes (visuales y no visuales) definidos
por el usuario

COMPONENTES VISUALES Y NO VISUALES

Se puede establecer muchas clasificaciones para los componentes. Una de ellas

es la de visuales o controles, frente a no visuales.
Un componente es visual cuando tiene una representación gráfica en tiempo de
diseño y ejecución (botones, barras de scroll, cuadros de edición, etc.), y se dice
no visual en caso contrario (temporizadores, cuadros de diálogo-no visibles en la
fase de diseño, etc). Por lo demás no existen más diferencias entre ellos, excepto,
claro está, las derivadas de la visualización del componente.
 Los componentes no visuales se pueden colocar en los formularios de la misma
manera que los controles, aunque en este caso su posición es irrelevante.
Para empezar, los componentes visuales podemos dividirlos a su vez en dos tipos:
-Componentes interactivos: permiten que el usuario final los manipule, ya sea
introduciendo datos, seleccionado elementos, etc. De forma que estos
componentes pueden recibir el foco (con SetFocus) así como los eventos propios
del teclado y del ratón. Normalmente, el propio sistema operativo es el encargado
de dibujar el aspecto del componente, haciendo el componente las llamadas
correspondientes para que este aspecto cambie.

Componente gráficos: el propio componente es el encargado de dibujar en la

pantalla lo que crea oportuno, bien a través de las funciones básicas del API de
Windows (con el objeto TCanvas) o bien a través de otras librerías gráficas, como
OpenGL, DirectX, etc. Estos componentes, no suelen recibir eventos del usuario
final, aunque si eventos del propio programador, ya que su cometido no suele ir
más allá de mostrar ciertos gráficos o imágenes en la pantalla.
 Si tuviéramos que crear un componente interactivo desde el principio, sería
demasiado complejo, ya que tendríamos que luchar encontrar el propio API del
sistema operativo, gestionando sus mensajes, las llamadas las funciones a bajo
nivel, etc. Sin embargo, podemos aprovechar la mayoría del trabajo hecho por
Borland en la VCL, y crear componentes interactivos a partir de otros ya
existentes, aplicado la técnica de herencia.
Dado que un componente es un objeto como otro cualquiera, podremos aplicar en
el todas las técnicas de la orientación a objetos: encapsulación, herencia y
polimorfismo.
La encapsulación ya la hemos utilizado sin apenas darnos cuenta, simplemente
definiendo ciertos atributos como privados, para que no puedan ser accedidos
desde fuera de la clase, y otros públicos o publicados (pulished) para ser usados
por el programador que utilice el componente.    

La herencia nos permite reutilizar código, haciendo que una  clase dada (que
llamaremos clase hija) adquirida a todos los atributos y métodos públicos y
protegidos de otra, llamada clase padre. De este método, podemos aprovechar
mucho código escrito, simplemente heredando de una clase ya escrita. Por si
fuera poco, también es posible que una clase hijo tenga a su vez mas
descendencia, adquiriendo estos las características del padre y del "padre del
padre", es decir: del abuelo.
La técnica de la herencia, aplicada a los componentes, nos permite personalizar
cualquier componente, o porque queremos ampliar las posibilidades del
componente.

La propia VCL utiliza la herencia continuamente, bien para utilizar código de

clases padre, o bien para ofrecernos clases padre de las que nosotros podemos
heredar. Muchas "suites de componentes" hacen también esto, proporcionando un
componente heredando a partir de cada uno de los básicos, y añadiendo en estas
nuevas características.

Para explicar cómo crear un componente interactivo, vamos a hacerlo a través de

un ejemplo práctico: supongamos que necesitamos mostrar un árbol que muestre
los directorios a partir de una carpeta dada, incluso pongamos que necesitamos
mostrar el típico árbol de "MI PC", mostrando todas las unidades y las carpetas de
cada una.

Para ello, podríamos escribir un componente desde cero, gestionando todo lo

referente a la estructura en árbol, el dibujo en pantalla, la gestión de mensajes,etc.
Podríamos utilizar la herencia para utilizar el código ya escrito, concretamente
basándose en el componente ATTreeVienw, que es el que nos permite mostrar en
un formulario estructuras del tipo árbol. Sin embargo, el TTreeVienw que viene por
defecto en el Delphi, es muy genérico, y sirve para mostrar cualquier ripo de árbol.
Nuestro caso es mas  específico: necesitamos mostrar un árbol, sí, pero más
concretamente un árbol de directorios. Llamaremos a nuestra nueva creación
TArbolDirectorios.
Sólo vamos a fijarnos a partir TComponent:
TComponent: este nos resulta familiar, ya que es la clase a partir de la que hemos
creado en nuestro conversor de monedas de anteriores números. Los
componentes  no-visuales deben heredar directamente de TComponent, ya que
este proporciona las características básicas.
TControl: se trata de la clase padre para todos los componentes visuales, ya sean
gráficos o no.
TWinControl: de esta clase descenderán todos los componentes dibujados
directamente por Windows. La principal característica de estos objetos (llamados
ventanas o Windows) es que están identificados por un número único llamado
descriptor o manejadores de ventana (en inglés handle).
TCustomTreeView: se trata de la clase que permite mostrar un árbol dentro de un
formulario de Delphi. La peculiaridad es que esta clase no contiene ningún método
ni propiedad en la sección published, por lo que puedes ser manejada desde el
entorno de Delphi.
TTreeView: esta ya es la clase o componente final, que aparece registrado en la
paleta de componentes, y que puede ser configurado en tiempo de diseño. En
realidad, todo el trabajo de esta clase se limita a publicar las propiedades y
eventos que han sido programados en la clase TCustomTreeVienw.
Ahora que ya sabemos quíen va  a ser el padre de nuestro componente, tenemos
que decir qué propiedades y eventos vamos a proporcionar a nuestros usuarios
del componente.
CarpetaRaiz: se trata de una cadena que contendrá la carpeta a partir de que se
creará el árbol de directorios. Puede ser la carpeta raíz de una unidad de
disco(p.e."C:\") para mostrar los directorios de toda la unidad, o bien una carpeta
cualquiera , para mostrar las subcarpetas de esta. Un caso se dará cuando esta
propiedad contenga el valor "Mi PC", con en el que mostraremos cada una de las
unidades disponibles en nuestro sistemas, pudiendo expandir estas unidades para
mostrar sus carpetas.
CarpetaActual: es el valor de tipo cadena que contiene la ruta de la carpeta
seleccionada en el árbol, por ejemplo. Si, por ejemplo, tenemos seleccionada la
carpeta de primer nivel "Datos", y el nodo raíz es "C:\Temporal", esta propiedad
contendrá el valor  "C:\Temporal\Datos". También se puede modificar su valor,
seleccionándose en ese caso el modo correspondiente en el árbol (si el valor
establecido es correcto).
MostarPadre: es un valor booleano (true o false) que nos permite configurar la
aparición no del nodo padre. Es decir: si en la propiedad "CarpetaRaiz" hemos
introducido  el valor  "C:\Delphi", en el árbol aparecerá un nodo raíz llamado
"Delphi", y colgado de él, todas las demás subcarpetas. Si establecemos esta
propiedad a falso, el nodo raíz desaparecerá, mostrándose todas las subcarpetas
en un primer nivel, sin colgar de ningún nodo padre.

Una interfaz grafica está construida en base a elementos gráficos básicos, los
componentes.Típicos ejemplos de estos componentes son los botones, barras de
desplazamientos, etiquetas, listas, cajas de selección o campos de textos. Los
componentes permiten al usuario a interactuar con la aplicación y proporcionar
información  desde el programa al usuario sobre el estado del programa. En el
AWT, todos los componentes de la interfaz de usuario son instancias de la clase
componente o uno de sus subtipos.

Los componentes no se encuentran aislados, si no agrupados dentros de

contenedores. Los contenedores contienen y organizan la situación de los
componentes y como tales pueden ser situados  dentro de otros contenedores.
También contienen el código necesario para el control de eventos, cambiar la
forma del cursor o modificar el icono de la aplicación. En el AWT todos los
contenedores son instancias de la clase Container o uno de sus subtipos.

La clase componente es una clase abstracta que representa todo lo que tiene una
posición, un tamaño, puede ser pintado en pantalla y puede recibir eventos. No
tiene constructores públicos, ni puede ser instanciada. Sin embargo, la clase
Component puede ser extendida para proporcionar una nueva característica
incorporada a java, conocida como componentes ligeros  o Lightweight.

Los objetos derivados de la clase Component que se incluyen en el abstract

window Toolkit son los que aparecen a continuación:

Button                                             Label
Canvas                                            List
Checkbox                                        Scrollbar
Choice                                           TextComponent
Container                                        TextArea
Panel                                               TextField
Window
Dialog
Frame

Sobre estos componentes se podrán hacer mas agrupaciones y quizá la más

significativa fuese la que diferencie a los componentes según el tipo de entrada. A
si habría componentes con entrada de tipo no-textual como los botones de
pulsación (Button), las listas (List), botones de marcación (checkbox), botones de
seleccion (Choice), y botones de comprobación (CheckboxGroup); componentes
de entrada y salida textual como los campos de texto (TextField), las áreas de
texto (TextArea) y las etiquetas (Label); y, otros componentes sin acomodo fijo en
ningún lado, en donde se encontrarían componentes como las barras de
desplazamiento(Scrollbar), zonas de dibujo (Canvas) e incluso los contenedores
(Panel, Window, Dialog y Frame), que también pueden considerarse como
componentes.

La clase Button es aquella que produce un componente de tipo boton con un

titulo.El constructor mas utilizado es el que permite pasarle como parametro una
cadena, que sera la que aparezca como titulo e identificador del boton en la
interfaz de usuario.

Botones de selección
Los botones de selección (Choice) permiten el rápido acceso a una lista de
elementos, presentándose como titulo en el item que se encuentre seleccionado.
La clase choice extiende la clase component e implementa la interfaz
ItemSelectable, que es aquella que mantiene un conjunto de items en los que
puede haber, o no, alguno seleccionado.
Botones de comprobación
La clase CheckBox extiende la clase Componet e implementa la
interfaz ItemSelectable, que es aquella que contiene un conjunto de ítems entre
los que puede haber o no alguna seleccionado.

Los botones de comprobación (Checkbox) se puede agrupar para formar una

interfaz de botón de radio (CheckboxGroup),que son agrupaciones de botones
de comprobación de exclusión múltiple es decir, en la que siempre hay
un único botón activo.

Ejemplo:
2.4 Creación y uso de paquetes/librerías definidas por el usuario

Los paquetes son grupos de clases relacionadas; ayudan a organizar su código y

proporcionan otra capa encapsulamiento.
En programación, los paquetes, con frecuencia son útiles para agrupar las piezas
relacionadas de un programa.
Un paquete sirve para dos propósitos: primero, suministra un mecanismo por el
cual piezas relacionadas de un programa pueden ser organizadas como una
unidad. Se debe tener acceso a las clases definidas dentro de un paquete
a través de su nombre de paquete. Así, un paquete proporciona la manera de
nombrar una colección de clases.
Segundo, un paquete participa en los mecanismos de control de acceso en java.
Las clases definidas dentro de un paquete pueden hacerse privadas a ese
paquete y no accesibles por código fuera del paquete. De este modo, el paquete
suministra un medio por el cual las clases pueden ser encapsuladas.

DEFINIR UN PAQUETE:

Todas las clases en Java pertenecen a algún paquete. Como se mencionó

anteriormente, cuando no se especifica la declaración  package se usa
el paquete predeterminado (o global). Además, el paquete predeterminado no
tiene nombre, lo que lo hace transparente. 
Aunque el paquete predeterminado es válido para programas de prueba cortos, es
inadecuado para aplicaciones reales.

Para crear un paquete, coloque un comando package en la parte superior del

archivo fuente de java.
Las clases declaradas dentro de ese archivo pertenecerán al paquete
específicado. Puesto que un paquete define un espacio de nombre, los nombres
de las clases que coloque dentro del archivo se convierten en parte de ese
espacio del nombre del paquete.

La siguiente es la forma general de la declaración package:

        package pkg;
Aquí, pkg es el nombre del paquete. Por ejemplo, el siguiente enunciado crea un
paquete de nombre Project1.

Package Project1.

Java usa el sistema de archivo para manejar los paquetes con cada paquete
almacenado en su propio directorio. Por ejemplo, los archivos .class para las
clases que usted declare sean partes de Project1 debe guardarse en un directorio
llamado Project1.
Puede crear una jerarquía de paquetes. Para hacerlo, simplemente, separe cada
nombre de paquete del inmediatamente anterior, por medio de un punto.
A continuación, la forma general de una declaración de paquete multinivel:

     package pack1.pack2.pack3....packN;

Por supuesto, debe crear directorios que soporten la jerarquía del paquete que
crea. Por ejemplo:

Paquete x,y,z;

Debe almacenarse en  ...../X/Y/Z, donde ... especifica la ruta a los

directorios específicos.

ENCONTRAR PAQUETES Y CLASSPATH:

Como se explicó, los paquetes son reflejados por los directorios. Esto provoca una
pregunta importante: ¿Cómo sabe el sistema en tiempo de ejecución  de java
dónde buscar los paquetes que usted creó? La respuesta tiene dos partes.
Primero, por defecto: el sistema de tiempo de ejecución de java busca en el
directorio un curso como su punto de partida. Así, si sus archivos de
clase están en el directorio actual, o en un subdirectorio del directorio actual, ellos
se encontrarán. Segundo, puede especificar una ruta o rutas de directorios
colocando la variable ambiental CLASSPATH.   
    Por ejemplo considere la siguiente especificación de paquete:

   package MyPack;

Para que un programa encuentre MyPack, una de estas opciones debe ser cierta:
el programa es ejecutado desde un directorio inmediatamente anterior a MyPack,
o CLASSPATH debe crearse para incluir la ruta a MyPack. La primera alternativa
es la mas fácil (y no requiere un cambio a CLASSPATH), pero la segunda le
permite a su programa encontrar MyPack sin importar en cual directorio esta el
programa.

UN EJEMPLO BREVE DE UN PAQUETE:

Teniendo en cuenta la discusión anterior pruebe este ejemplo breve de paquete.

Éste crea una base de datos simple de libro que esta contenido dentro del paquete
BookPack.
Llame este archivo BookDemo.java y colóquelo en un directorio de
nombre BookPack.
Luego, compile el programa. Asegúrese de que el archivo resultante .class esté
también en el directorio BookPack. Luego trate de ejecutar la clase, usando la
siguiente linea de comando:

   java BookPack. BookDemo

Recuerde, necesitará estar en el directorio anterior de BookPack cuando ejecute

este comando o hacer que su variable ambiental CLASSPATH, este configurada
apropiadamente.
Como se dijo, BookDemo y Book ahora son parte del paquete BookPack. Esto
quiere decir que BookDemo no puede ser ejecutado por sí mismo. Es decir, usted
no puede usar esta línea de comando.

   java BookDemo

En cambio, BookDemo debe calificar con su nombre de paquete.

PAQUETES Y ACCESO A MIEMBROS

La visibilidad de un elemento está determinada por su especificación de

accesos, private, public. protected o por defecto, y el paquete en el que éste
resida.De este modo, la visibilidad de un elemento está determinada por
su visibilidad dentro de la clase y su visibilidad dentro del paquete.
Si un miembro de una clase no tiene especificador de acceso explícito, entonces
éste sería visible desde dentro de su paquete pero no por fuera de él. Por esto
debe usar como la especificación de acceso por defecto para los elementos que
quiera mantener como privados en un paquete, pero |público| dentro de ese
paquete.
Los miembros declarados public explícitamente son visibles en todas partes,
incluidas en clases y paquetes diferentes. No hay restricción en su uso o acceso.

La siguiente tabla resume los variados niveles de acceso a miembros.

Un miembro private es accesible sólo para otro miembro de su clase y no es
afectado por su afiliación a un paquete.
Un miembro especificado como protected es accesible dentro de su paquete y a
todas las subclases. incluidos. subclases en otros paquetes.
Una clase tiene sólo dos posibles niveles de acceso : por defecto y público.
Cuando una clase se declare como prublic, ésta es accesible por cualquier otro
código. Si una clase tiene acceso por defecto, puede tener acceso a ella sólo por
otro código dentro de su mismo paquete. También, una clse que se
declare public debe residir en un archivo del mismo nombre.

IMPORTAR PAQUETES:

 Cuando use una clase de otro paquete, puede calificar completamente el nombre
de la clase cuete.on el nombre de su paquete. Sin embargo,
tal aproximación puede fácilmente llegar a ser aburrida y complicada, si las clases
que está calificando son profundamente anidadas en la jerarquía del paquete.
Usando import puede traer uno o más miembros de un paquete a la vista. Esto le
permite usar directamente aquellos miembros, sin hacer explícita las calificaciones
del paquete.
A continuación, la forma general de la declaración import:

    import pkg.nombre de clase; 

Donde pkg es el nombre del paquete, que puede incluir su ruta (path) completa
y nombre de clase  el de la clase importada. Si desea importar todo el contenido
de un paquete, use un asterisco (*) para el nombre de clase. A continuación,
ejemplos de las dos formas:
Import MyPack.MyClass

Import <MyPack,*;

En el primer caso, la clase MyClass es importada de MyPack. En el

segundo,todas las clases en MyPack son importadas. En un archivo fuente de
java, las declaraciones import ocurren en seguida de la declaración package (si
existe) y antes de cualquier definición de clase.
    Usted puede usar import para traer el paquete BookPack a la vista, de modo
que la clase Book pueda usarse sin calificación. Para hacer esto, sólo adicione
la declaración import sobre cualquier archivo que use Book.

import BookPack,*:

Por ejemplo, a continuación está la clase UseBook recodificada para usar import

LA LIBRERIA DE  CLASE JAVA ESTA CONTENIDA EN PAQUETES:

Esta libreria de clase con frecuencia se refiere a la Interfaz de Programación de

Aplicaciones de java (Java API, Application Programming Interface). La Java API
se almacena en paquetes. En la parte superior de la jerarquía del paquete
está java. 
Descendiendo desde java hay varios subpaquetes, incluidos estos:
  
java.lang:  contiene un gran número de clases de propósito general
java.io:     contiene las clases de E/S
java.net:   contiene aquellas clases que soportan redes
java.applet: contiene clases para crear applets
java.awt:     contiene clases que soportan las herramientas abstractas para
trabajar con ventanas de java

El paquete java.lang es único porque es importado automáticamente dentro de
cada programa java.  

Bibliografías
Schildt, H., & Patarroyo Fuentes, J. (2002). Fundamentos de programación en
Java 2.

Alejandro, S. O. D. Fundamentos De Programación-IS57-200901.

Mazón Olivo, B. E., Cartuche Calva, J. J., Chimarro Chipantiza, V. L., & Rivas
Asanza, W. B. (2015). Fundamentos de programación orientada a objetos en
JAVA.

de Guevara, J. M. L. (2014). Fundamentos de programación en Java.

http://progitca.blogspot.com/2012/03/35-creacion-y-uso-de-
paqueteslibrerias.html