Download Modulos de programa en Java

Módulos de programa en Java.
Los módulos en Java se llaman métodos y clases. Los programas en Java se escriben
combinando métodos nuevos que el programador escribe con métodos “preempacados“
disponibles en la Java API (también conocida como la biblioteca de clases de Java) y
combinando clases nuevas que el programador escribe con clases “preempacadas”
disponibles en diversas bibliotecas de clases.
Un método se invoca (es decir, se le pide realizar una tarea designada) con una
llamada de método. La llamada de método especifica el nombre del método y proporciona
la información (en forma de argumentos) que el método necesita para hacer su trabajo.
Métodos.
Los métodos permiten al programador modularizar sus programas. Todas las
variables declaradas en las definiciones de métodos son variables locales: sólo se conocen
en el método en el que se definen. Casi todos los métodos tienen una lista de parámetros
que permiten comunicar información entre métodos. Los parámetros de un método también
son variables locales.
Definición de métodos.
El nombre de método es cualquier identificador valido. El tipo de valor devuelto es
el tipo de datos del resultado que el método devuelve al invocador.
La lista de parámetros es una lista separada por comas que contiene las
declaraciones de los parámetros que el método recibe cuando se le invoca. Si un método no
recibe valores, la lista de parámetros está vacía (es decir, se coloca un juego de paréntesis
vacío después del nombre del método. Se debe listar explícitamente un tipo para cada
parámetro de la lista de parámetros del método.
Hay tres formas de devolver el control al punto en el que se invocó un método. Si el
método no devuelve un resultado, el control se devuelve simplemente caundo se llega a la
llave derecha que termina el método, o al ejecutarse el enunciado:
return
Si el método devuelve un resultado, el enunciado:
return expresión;
devuelve el valor de expresión al invocador. Cuando se ejecuta un enunciado return
(regresar), el control regresa de inmediato al punto en el que se invocó al método.
Reglas de alcance
El alcance de un identificador es la porción del programa en la que se puede hacer
referencia a dicho identificador. Por ejemplo cuando declaramos una variable local en un
bloque, sólo podemos referirnos a ella en ese bloque o en los bloques anidados dentro de
ese bloque. Los alcances de los identificadores son alcance de clase y alcance de bloque.
El alcance de clase comienza en la llave izquierda { que indica la definición de la
clase y termina en la llave derecha } que cierra dicha definición. El alcance de clase permite
a los métodos de una clases invocar directamente todos los métodos definidos en la misma
clase o heredados en la clase.
Los identificadores declarados dentro de un bloque tienen alcance de bloque. El
alcance de bloque comienza en la declaración del identificador y termina en la llave
derecha } que termina el bloque. Las variables locales declaradas al principio de un método
tienen alcance de bloque, lo mismo que los parámetros de un método, que también son
variables locales del método. Cualquier bloque puede contener declaraciones de variables.
Cuando se anidan los bloques, y un identificador de un bloque exterior tiene el mismo
nombre que in identificador de un bloque interior, el compilador genera un mensaje de
error de sintaxis para indicar que la variable ya está definida
Administración de memoria
Java utiliza un modelo de memoria conocido como "administración automática del
almacenamiento” (automatic storage management), en el cual el sistema en tiempo de
ejecución mantiene un seguimiento de los objetos.
En la siguiente figura se muestra la arquitectura interna de la JVM
Subsistema
cargador de
clases
Archivos
class
Area de
métodos
heap
Stack
Java
registros
pc
Stack
métodos
nativos
Areas de datos en tiempo de ejecución
Motor de
ejecucion
Interface de
métodos
nativos
Librerias de
métodos
nativos
Cuando una JVM ejecuta un programa, esta necesita memoria para guardar muchas
cosas, incluyendo bytescodes y otra información que se extrae de los archivos class
cargados, los objetos del programa instanciados, los parámetros de los métodos, valores de
retorno, variables locales, y resultados intermedios de computo. La JVM organiza la
memoria que necesita en para ejecutar un programa en varias áreas de datos en tiempo de
ejecución.
Diferentes implementaciones de la maquina virtual pueden tener diferentes
restricciones de memoria, algunas implementaciones tienen gran cantidad de memoria en la
cual trabajar, otras tienen muy poca.
Cada instancia de la JVM tiene un área de métodos y un heap, estas áreas son
compartidas por todos los threads que se están ejecutando dentro de la JVM. Cuando la
JVM carga un archivo class, esta parsea información acerca del tipo de datos binarios
contenidos en el archivo class, esta coloca la información de tipo dentro del area de
métodos, Cuando el programa se ejecuta, la JVM coloca los objetos del programa
instanciados dentro del heap.
Cada nuevo thread que inicia su existencia, contiene un registro pc (program couter)
y un stack Java. Si el thread esta ejecutando un método Java (no un método nativo) el valor
del registro pc indica la próxima instrucción a ejecutar. Un stack Java de threads guarda el
estado de la invocación del método Java (no nativo). El estado de la invocación de un
método en Java incluye sus variables locales, los parámetros con los cuales fue invocado,
su valor de regreso y cálculos intermedios.
El Stack Java esta compuesto por frames. Un frame de stack contiene el estado de
la invocación de un método de Java. Cuando un thread invoca un método, la JVM guarda
un nuevo frame dentro de thread del Stack de Java. Cuando el método es completado, la
JVM saca y descarta el frame del método.
Recolección de basura:
La función primaria de un GC es reclamar automáticamente la memoria usada por
los objetos que no tienen referencia en la aplicación que se ejecutando actualmente.
Esta también puede mover objetos de la aplicación que se esta ejecutando para evitar la
fragmentación del heap.
El GC no es requerido en la especificación de la JVM.
La especificación solo requiere que una implementación maneje el heap de alguna
forma.
La especificación de la JVM no dice cuanta memoria debe dejar una
implementación para poder ejecutar programas.
La JVM no menciona como una implementación debe manejar su heap.
Java usa mark-and-sweep.
Altamente confiable, pero puede causar inexplicables bajas de velocidad.
Java realiza la recolección de basura cuando el programa tiene algún tiempo de
reserva
Se puede invocar al recolector usando el método gc de la clase System.
Procesamiento distribuido
Las aplicaciones RMI a menudo se componen de dos programas separados: un
servidor y un cliente. Una típica aplicación de servidor crea algunos objetos remotos, crea
referencias para que estos sean accesibles y espera por clientes que invoquen métodos en
estos objetos remotos. Una aplicación cliente típica obtiene una referencia remota de uno o
mas objetos remotos en el servidor y entonces invoca los métodos. RMI provee el
mecanismo por el cual el servidor y el cliente se comunican y pasan información de un lado
para el otro. Este tipo de aplicación es conocido como aplicación de objetos distribuidos.
Las aplicaciones de objetos distribuidos necesitan de:
Localizar objetos remotos: Las aplicaciones pueden usar uno o dos mecanismos
para obtener referencia de objetos remotos. Una aplicación puede registrar estos objetos
remotos, la aplicación rmiregistry, o la aplicación puede pasar y regresar referencias como
parte de su operación normal.
Comunicar con objetos remotos: Los detalles entre la comunicación entre objetos
remotos son manejados por RMI, para el programador la comunicación remota se ve como
una invocación estandar de un método de Java.
Cargar bytecodes de clases para objetos que son pasados: Porque RMI permite que
un llamador pase objetos a objetos remotos, RMI provee los mecanismos necesarios para la
carda de código del objeto, así como también de la transmisión de sus datos.
Creando aplicaciones distribuidas usando RMI.
Cuando se usa RMI para desarrollar aplicaciones distribuidas, se siguen los
siguientes pasos generales.
1.- Diseñar e implementar componentes de la aplicación distribuida.
2.- Compilar fuentes y generar esqueletos (stubs).
3.- Hacer las clases accesibles a través de la red.
4.- Comenzar la aplicación.
Diseñar e implementar componentes de la aplicación.
Primero, decida la arquitectura de la aplicación y determine cuales componentes son
objetos locales y cuales deberían ser accesibles remotamente. Este paso incluye:
Definir la interfaces remotas: Una interface remota especifica los métodos
que pueden ser invocados remotamente por un cliente. Los programas clientes a interfaces
remotas, no la implementación de clases de estas interfaces, Parte del diseño de tales
interfaces es la determinación de cualquier objeto local
que podrá ser usado como
parámetros y valores de retorno de estos métodos.
Implementando los objetos remotos: Los objetos remotos deben implementar una
o mas interfaces remotas
Implementando los clientes: Los clientes que los objetos remotos usan pueden ser
implementados en cualquier momento después de que las interfaces remotas son definidas,
incluso después de que los objetos remotos hayan sido desarrollados.
Compilando fuentes y generando esqueletos (stubs):
Este es un proceso de dos pasos, en el primero se usa el compilador javac para
compilar los archivos fuentes, los cuales contienen la implementación de las interfaces
remotas, las clases del servidor y las clases del cliente, en el segundo paso se puede usar el
compilar rmic para crear stubs para los objetos remotos
Hacer las clases accesibles a través de la red:
En este paso se hacen accesible todos los archivos de clases asociados con las
interfaces remotas, stubs, y otras clases que necesitan ser bajadas por los clientes vía un
servidor de Web.
Comenzar la aplicación:
Comenzar la aplicación incluye ejecutar el remote object registry, el servidor y el
cliente