P. 1
T2-modularidad

T2-modularidad

|Views: 2.372|Likes:
Publicado porfundamentos41dued
MODULArIDAD JAVA
MODULArIDAD JAVA

More info:

Published by: fundamentos41dued on Aug 26, 2009
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

05/11/2014

pdf

text

original

Contenidos

Conceptos básicos

1. ¿Por qué modulamos las aplicaciones?

Tema 2
Modularidad

1. ¿Cómo se debe modular una aplicación? 1. Factores a considerar para determinar si
una aplicación está bien modulada

1. Tipos de módulos 1. Modularidad en Java
2

Referencias
[Meyer, 99] Tema 2, 8, 14 mindview.net/Books/TIJ4 www.javaworld.com java.sun.com www.gamelan.com

Modularidad
Objetivos:
Se presentará el concepto de Modularidad, imprescindible para desarrollar proyectos grandes. Se expondrá cómo se modularizan las aplicaciones y las ventajas de la modularidad. Recordaremos el concepto de Tipo Abstracto de Datos ligándolo a los dos conceptos anteriores. A modo de ejemplo revisaremos los recursos que 4 proporciona el lenguaje de programación Java para permitir la modularidad

3

1. Conceptos básicos: Diseño modular
Construcción de una cocina

1. Conceptos básicos: Estructura de los módulos
Electricista Nombre Necesita que Dependencias

Qué hace rozas …
5

Qué hace Instalación eléctrica Interfaz

Cómo lo hace Instalación eléctrica Implementación
8

1

1. Conceptos básicos
Encapsulación Los módulos contienen:
Los datos que utilizan (herramientas) Las operaciones que tratan los datos (servicios que ofrece)

1. Conceptos básicos
Ejemplo de Mala Ocultación Si el fontanero no proteje su sistema de facturación, cualquiera puede modificar sus tarifas o manipular sus facturas

Ocultación de la información Los datos locales de los módulos no deben ser visibles desde el exterior (a nadie le importa qué herramientas utiliza) Los módulos sólo pueden ser utilizados desde el exterior a través de las operaciones públicas (hay que solicitarle que haga las labores necesarias, no las hace cualquiera usurpando su lugar) Ventajas
Facilitan la modificabilidad (el obrero ya sabe lo que ha hecho y lo

permiso a ningún otro gremio) Favorecen el desarrollo independiente (cada gremio sólo tiene que saber hacer su trabajo) Mejoran la inteligibilidad (normalmente cada labor corresponde a un gremio)

modifica facilmente; hace cursos de reciclaje sin tener que pedir

11

12

1. Conceptos básicos
Acoplamiento (coupling): mide la fuerza de la interconexión de los módulos
Queremos módulos débilmente acoplados para que se puedan tratar independientemente Dependencias entre gremios identificadas y minimizadas

1. Conceptos básicos
Ejemplos de Acoplamiento [Meyer,99]

Cohesión (cohesion): mide lo estrechamente ligados que están entre sí los elementos internos de un módulo
Queremos módulos con fuerte cohesión No queremos que ningún obrero sea el chapuzas que 14 hace de todo pero nada bien. Queremos gente

15

Interfaz - Dependencias
HInstalar

2. ¿Por qué modulamos las aplicaciones?
Descomponer el problema en partes más simples El sistema está compuesto de una serie de módulos independientes comunicados entre sí Las modificaciones debidas a cambios en la especificación afectan a un número reducido de módulos

Electricista
HRozas

Albañil

Facilitar la comprensión del sistema y de cada una de sus partes

Si se produce un error en un módulo, éste sólo afecta a dicho módulo
18 20

2

3. ¿Cómo se debe modular una aplicación?
El módulo debe dejar bien claro cómo hacer uso de él
M1

abstracción

El acceso a los servicios de un módulo debe ser homogéneo
M4
BOTTOM-UP TOP-DOWN

M2

M3

M5

M6

M7

M8

M9

El lenguaje de programación utilizado debe soportar el uso de módulos

Un módulo debe estar listo para su uso pero a su vez debe poder mejorarse
31

a) Unidades modulares lingüísticas

b) Autodocumentación
El constructor del módulo debe intentar incluir toda la documentación en el propio módulo El código del módulo NO puede ser su documentación La documentación incluye el diseño y la utilización del módulo

El lenguaje de programación utilizado debe soportar el uso de módulos. Los módulos identificados deben corresponderse con las unidades sintácticas de dicho lenguaje.

33

34

c) Acceso Uniforme
Los servicios que ofrece un módulo deben utilizarse de forma uniforme A pesar de cambiar la implementación, la forma de utilizar el módulo debe mantenerse igual

d) Abierto - Cerrado
Los módulos deben estar abiertos y cerrados a la vez Abierto: el módulo puede ampliarse Cerrado: el módulo debe estar disponible para ser utilizado

35

36

3

4. Factores a considerar para determinar si una aplicación está bien modulada

4. Factores a considerar para determinar si una aplicación está bien modulada
a) Correspondencia directa
b) Pocas interfaces c) Pequeñas interfaces d) Interfaces explícitas e) Ocultación de la información

f) Tamaño g) Complejidad
37

h) Criterios para dividir en módulos

38

a) Correspondencia directa

b) Pocas interfaces
Cada módulo debe comunicarse con el menor número de módulos posible
Llamadas a subprogramas Estructuras de datos compartidas

La estructura del problema se debe reflejar en el programa

39

40

c) Pequeñas interfaces
En la comunicación entre módulos se debe intercambiar poca información

d) Interfaces explícitas

La comunicación entre módulos debe ser explícita y estar convenientemente documentada

41

42

4

e) Ocultación de la información
El diseñador del módulo debe elegir qué características serán explícitas El resto (la mayoría) serán privadas La funcionalidad (pública) y la implementación (privada) se han de separar Los otros módulos no pueden utilizar las características privadas de un módulo
43

f) Tamaño
Cuanto más pequeño sea el módulo será más comprensible Debemos buscar un equilibrio:
Si son muy pequeños, tendremos que gestionar muchos, la velocidad también puede verse afectada Si son muy grandes, tendrán mucha funcionalidad

Guía: Comenzar diseñando y creando módulos pequeños, rediseñar los módulos incluyendo44 los procedimientos más empleados

g) Complejidad
Los programas se deben hacer lo más claros posible
Reducir el tiempo de desarrollo Facilitar el mantenimiento

h) Criterios para dividir en Módulos
División con respecto a las tareas:
Por cada tarea se crea un módulo Puede ocurrir que todos los módulos deban acceder a datos globales y/o que deban interactuar con el usuario Problema: Desde muchos puntos de la aplicación se pueden cambiar los datos

¿Cómo se mide la claridad?
Número de ciclos

Guías:
Elegir los algoritmos más sencillos Los subprogramas deben contener el menor número posible de ciclos anidados 45

46

g) Criterios para dividir en Módulos
División con respecto a los datos:
Cada módulo incluirá una de las estructuras de datos identificadas en el problema Cada módulo encapsula:
Sus datos Operaciones para acceder a los datos Operaciones para cambiar los datos

Procedimiento
Identificar los módulos que componen la aplicación Para diseñar un módulo, en primer lugar identificaremos los recursos que exporta: la interfaz del módulo/clase Se realiza una especificación de las operaciones que exporta el módulo/clase indicando datos de entrada y salida Esta especificación se ha de estudiar mucho para que no varíe cuando surjan nuevos requisitos
48

Solamente se puede acceder a los datos a través de un conjunto concreto de operaciones (encapsulamiento + ocultación de la 47 información)

5

Procedimiento
Una vez realizada la especificación de la interfaz de la clase se puede proceder a su implementación Si separamos especificación e implementación obtendremos un módulo que proporcionará servicio a pesar de que se produzcan cambios en la implementación o se incluyan más operaciones La especificación puede ir ampliándose, probablemente ocurrirá así con nuevos refinamientos y aplicaciones de la clase
49

5. Tipos de módulos
a) Módulos de definición b) Módulos de servicio c) Tipos Abstractos de Datos d) Máquinas Abstractas de Estado

50

a) Módulos de Definición

b) Módulos de Servicio

Conjunto de declaraciones
definiciones de constantes definiciones de variables

Ofrecen un servicio Agrupan un conjunto de operaciones Por ejemplo un módulo de operaciones matemáticas

Sin operaciones

51

52

c) Tipos Abstractos de Datos
Un TAD es una abstracción de datos. Encapsula un conjunto de datos y operaciones Tipos de Datos: especifican los valores y operaciones permitidos
Básicos: entero, caracter, … Estructurados: tablas, colas, pilas…

c) Tipos Abstractos de Datos
La representación de los datos y la implementación de las operaciones se oculta La implementación se realiza a través de subprogramas

Tipos de Operaciones:
Construcción Acceso Modificación

53

54

6

c) Tipos Abstractos de Datos
Componentes de los TAD:
Especificación
Sintaxis: especifica los nombres de las operaciones, tipo de los argumentos y tipo de los resultados Semántica: describe el comportamiento de las operaciones (modo formal o informal)

c) Tipos Abstractos de Datos
Ejemplo: Secuencia de números naturales (SECNAT) Especificación sintáctica:
CREAR: SECNAT PONER: SECNAT x N SECNAT PRIMERO: SECNAT N RESTO: SECNAT SECNAT LONGITUD: SECNAT N CONCATENAR: SECNAT x SECNAT SECNAT INVERSA: SECNAT SECNAT
56

Implementación
Representación: estructura de los elementos del TAD, tipos de datos básicos (proporcionados por el LP o por otro TAD) Operaciones: Implementación del comportamiento (funcionalidad) 55

c) Tipos Abstractos de Datos
Especificación semántica:
CREAR: construye la secuencia vacía PONER(S, N): coloca N como primer elemento de S PRIMERO(S): devuelve el primer número natural de la secuencia S RESTO(S): obtiene la secuencia resultante de eliminar de S su primer elemento LONGITUD(S): devuelve el número de elementos de S CONCATENAR(S1, S2): devuelve la secuencia formada por los elementos de S1 seguidos de los elementos de S2 INVERSA(S): devuelve la secuencia formada por los elementos de S en orden inverso
57

d) Máquinas abstractas de estado
Máquina abstracta de estados (MAE) El objeto está también encapsulado El estado del objeto en cada momento de la ejecución del programa se guarda en el módulo Sólo se exportan las operaciones no los datos Diferencia MAE-TAD:
TAD: diferentes objetos del mismo tipo MAE: un único objeto
58

Modularidad en Java 6. Modularidad en Java
Veremos cómo se implementan los conceptos de modularidad en el lenguaje de programación Java En Java la unidad modular es la clase Una clase es la abstracción de un conjunto de objetos (instancias) Una clase ofrece unos servicios y oculta otros recursos

59

60

7

Modularidad en Java
Es conveniente separar la especificación del módulo y su implementación
Especificación: declaración del conjunto de operaciones que se exportan (Interfaz del módulo) Implementación: parte del módulo que recoge la estructura de los datos y la implementación de las operaciones. Queda oculta
61

Modularidad en Java
Java no separa la especificación y la implementación de los módulos como lo hace Ada Especificación: definición de una interfaz Java con la declaración del conjunto de operaciones que exporta el módulo Implementación: definición de una clase Java que implementa la interfaz
Ocultaremos los detalles
62

Modularidad en Java
Interfaz
public interface IAlbañil { public void hacerRozas(); public void ponerBaldosas(); public void hacerPresupuesto(); …. }

Modularidad en Java
Implementación
public class Albañil extends Object implements IAlbañil { // Atributos public void hacerRozas() { //Codigo … } public void ponerBaldosas() { //Codigo … } public void hacerPresupuesto() { //Codigo … }

63

64

Ocultación de la información
Principio conservador :

Ocultación de la información
La ocultación de la información en Java se realiza a través de los modificadores de visibilidad Los modificadores de visibilidad se aplican a nivel de clase y a nivel de miembro (campo/método)

“A menos que exista una razón importante para que un miembro sea accesible, será declarado privado”

65

66

8

Modificadores de Visibilidad (clase)
Una clase puede declararse:
pública (public) en este caso todas las otras clases la pueden utilizar con la visibilidad a nivel de paquete, esto es, no se puede utilizar fuera del paquete si en un fichero se declaran más de una clase, sólo una será pública teniendo el resto visibilidad a nivel de paquete
67

Modificadores de Visibilidad (clase)
public: visible desde todas las clases

package (por defecto): si no existe el modificador public, el tipo de visibilidad se denomina package : sólo las clases del mismo paquete pueden ver y utilizar la clase
p1
package p1; Clase1 ... package p1; public Clase2
...

package p1; Clase3
...

68

Modificadores de Visibilidad (campos y métodos)
La visibilidad de las variables miembro (campos) y los métodos (operaciones) de una clase puede ser:
package (por defecto): sólo accesibles desde
su paquete (no se puede acceder desde sus subpaquetes) public: accesibles desde todas las clases private: sólo accesibles desde los métodos de la clase protected: el miembro es accesible desde las clases de su paquete y desde las subclases
69

Visibilidad
Desde una clase se puede acceder a:
Todos sus miembros Todos los miembros con visibilidad pública, protegida y predeterminada de las otras clases del paquete A los miembros públicos de las clases de los paquetes que importa
71

Ocultación de la información
El objetivo es ocultar en lo posible los detalles de implementación de las clases permitiendo el acceso sólo a través de la interfaz (miembros públicos)

Ocultación de la información
En Java para conseguir esto:
Las variables miembro (atributos) se deben declarar como privadas El acceso a las variables miembro se realizará SÓLO a través de las operaciones públicas Operaciones públicas de creación, consulta y modificación
72 73

9

Ocultación de la información
Usando los modificadores de visibilidad conseguimos:
evitar accesos directos controlar los accesos simplificar el trabajo del programador no tener problemas al cambiar la implementación del paquete mientras no se cambie la interfaz
74

Uso de interfaces
Ocultación de información A veces un módulo tiene diferentes clientes, y cada uno usa una parte diferente de la interfaz Varias interfaces diferentes Para implementar la evolución de un paquete Cada programador puede realizar las implementaciones de las interfaces que necesite adaptando la clase a sus necesidades
75

Importación de clases y paquetes
Para especificar las clases e incluso paquetes enteros que se utilizan desde una clase se utiliza la cláusula import
import <nombre-paquete> import <nombre-paquete> [[ {* || <nombre-clase>}] ;; {* <nombre-clase>}] *: se importan todas las clases del paquete *: se importan todas las clases del paquete <nombre-clase>: sólo se importa la clase referenciada <nombre-clase>: sólo se importa la clase referenciada

Importación de clases y paquetes
Para importar una clase:
import java.net.URL; public class Ejemplo {...}

Para importar todas las clases públicas de un paquete
import java.awt.*;

Esto no importa las clases incluidas en subpaquetes (por ejemplo , java.awt.event)

Una clase puede utilizar las clases públicas de todos los paquetes que se hayan referenciado al principio del fichero 76

El paquete java.lang no es necesario importarlo
77

Ámbito de identificadores
Alcance local: una variable local es visible a partir del punto de su declaración Alcance de método: un parámetro formal sólo es visible dentro del método Alcance de clase: un miembro se conoce en toda la extensión de la clase Alcance de archivo: un nombre de clase introducido por una sentencia import se conoce en todo el archivo Alcance de paquete: un nombre de clase o interfaz se conoce en todo el paquete Alcance de anfitrión: un nombre de paquete introducido por una sentencia package se conoce en todas las partes de un programa Java del mismo ordenador 78

Tipos de Módulos (Java)

a) b) c) d)

Módulos de definición Módulos de servicio Tipos Abstractos de Datos Máquinas Abstractas de Estado

79

10

a) Módulos de Definición
Declaración de constantes y variables Se declaran sobre clases abstractas (abstract) Se declaran como estáticas (static) Definiciones de constantes (final)
abstract static static static static static } class ConfiguracionSistema{ boolean VersionEvaluacion; int diasUtilización; final int maxDias; String ubicacion; String paginaInicial;
80

b) Módulos de Servicio
Ofrecen un servicio Agrupan un conjunto de operaciones Las operaciones de la interfaz se declaran sobre clases no instanciables (abstract y final) Las operaciones son declaradas estáticas (static)
81

b) Módulos de Servicio
abstract class UtilidadesString { static void aMayusculas(String S) {...} static void eliminarBlancos(String S) {...} static Boolean esPrefijo (String P, String S) {...} private static int interna(String P, String S) {...} }
82

c) Módulos de Abstracción de Datos
Representan TADs Se definen el tipo de datos y sus operaciones Las operaciones públicas se declaran en una interfaz Java La implementación se realiza sobre una clase Java

83

package packPilas; //Interfaz Pila public interface IPila { public int tamano(); // Devuelve el tamaño de la pila public boolean estaVacia(); // Indica si la pila está vacía

PILA

package packPilas; public class PilaArray extends Object implements IPila // Atributos private static final int CAP=1000; private int capacidad; private Object P[]; private int tope=-1; // Constructoras public PilaArray() {this (CAP);} public PilaArray(int cap){ capacidad=cap; P=new Object[capacidad]; } // Operaciones ...

PILA
{

public Object primero()throws ExcepcionPilaVacia; // Obtiene el primer elemento de la pila public void empilar (Object o) throws // Desempila el primer elemento public Object desempilar () throws //Empila un elemento } ExcepcionPilaLlena;

ExcepcionPilaVacia;

84

85

11

... // Operaciones public int tamano() {return (tope+1);} public boolean estaVacia() {return (tope<0);}

PILA

... // Operaciones public void empilar (Object o) ExcepcionPilaLlena{ if (tamano()==capacidad) throw new ExcepcionPilaLlena("llena"); P[++tope]=o;}

PILA
throws

public Object primero()throws ExcepcionPilaVacia { if (estaVacia()) throw new ExcepcionPilaVacia ("vacia"); return P[tope];} ...
86

public Object desempilar () throws ExcepcionPilaVacia{ Object elem; if (estaVacia()) throw new ExcepcionPilaVacia("vacia"); elem=P[tope]; P[tope--]=null; return elem; } }
87

package packComplejos; import java.io.*;

Dependencias

public interface INumComplejo { //devuelve la parte real public double parteReal(); //devuelve la parte imaginaria public double parteImaginaria(); //devuelve el módulo de un complejo public double modulo(); //devuelve el ángulo en grados public double argumento();

COMPLEJOS

... // calcula en el objeto el opuesto de un complejo public void opuesto(NumComplejo pC);

COMPLEJOS

// calcula en el objeto la suma de dos números complejos public void suma(NumComplejo pC1, NumComplejo pC2); // calcula en el objeto el producto de dos números complejos public void producto(NumComplejo pC1, NumComplejo pC2); //calcula en el objeto el producto de un real por un complejo public void producto(double pNum, NumComplejo pC); //calcula en el objeto el cociente de dos números complejos //excepción cuando el complejo denominador es cero public void cociente(NumComplejo pC1, NumComplejo pC2) throws ExcepcionDivideCero; ...
88 89

// calcula en el objeto el conjugado de un complejo public void conjugado(NumComplejo pC); ...

//calcula en el objeto el cociente entre un número complejo y un número real public void cociente(NumComplejo pC, double pNum)throws ExcepcionDivideCero; //calcula en el objeto el número e elevado a un número complejo public void exponencial(NumComplejo pC); //calcula en el objeto la raíz cuadrada de un número positivo o negativo public void csqrt(double pNum); //traduce un número complejo a un string public String toString(); //lee un número complejo public void leerComplejo () throws IOException; // imprime un número complejo public void putComplejo(); }

COMPLEJOS

package packComplejos; import java.io.*; import java.util.*; public class NumComplejo implements INumComplejo{ private double real; private double imag;

COMPLEJOS

public NumComplejo() { real=0.0; imag=0.0; } public NumComplejo(double pReal, double pImag){ this.real=pReal; this.imag=pImag; }

90

91

12

//devuelve la parte real public double parteReal(){ return real; } //devuelve la parte imaginaria public double parteImaginaria(){ return imag; } //devuelve el módulo de un complejo public double modulo(){ return Math.sqrt(real*real+imag*imag); } //devuelve el ángulo en grados public double argumento(){ double angulo=Math.atan2(imag, real); //el ángulo entre -PI y +PI if(angulo<0) angulo=2*Math.PI+angulo; return angulo*180/Math.PI; }

COMPLEJOS

//devuelve

92

// calcula en el objeto el conjugado de un complejo public void conjugado(NumComplejo pC){ real=pC.real; imag=-pC.imag; } // calcula en el objeto el opuesto de un complejo public void opuesto(NumComplejo pC){ real=-pC.real; imag=-pC.imag; } // calcula en el objeto la suma de dos números complejos public void suma(NumComplejo pC1, NumComplejo pC2){ real=pC1.real+pC2.real; imag=pC1.imag+pC2.imag; } // calcula en el objeto el producto de dos números complejos public void producto(NumComplejo pC1, NumComplejo pC2){ real=pC1.real*pC2.real-pC1.imag*pC2.imag; imag=pC1.real*pC2.imag+pC1.imag*pC2.real; 93 }

COMPLEJOS

//calcula en el objeto el producto de un complejo por un número real public void producto(double pNum, NumComplejo pC){ real=pC.real* pNum; imag=pC.imag* pNum; } //calcula en el objeto el cociente de dos números complejos //excepción cuando el complejo denominador es cero public void cociente(NumComplejo pC1, NumComplejo pC2)throws ExcepcionDivideCero{ double aux; if(pC2.modulo()==0.0){ throw new ExcepcionDivideCero("Divide entre cero"); }else{ aux=pC2.real*pC2.real+pC2.imag*pC2.imag; real=(pC1.real*pC2.real+pC1.imag*pC2.imag)/aux; imag=(pC1.imag*pC2.real-pC1.real*pC2.imag)/aux; }} //calcula en el objeto el cociente entre un número complejo y un número real public void cociente(NumComplejo pC, double pNum)throws ExcepcionDivideCero{ if(pNum==0.0){ throw new ExcepcionDivideCero("Divide entre cero"); }else{ real=pC.real/pNum; imag=pC.imag/pNum; }}

COMPLEJOS

//calcula en el objeto el número e elevado a un número complejo public void exponencial(NumComplejo pC){ real=Math.cos(pC.imag)*Math.exp(pC.real); imag=Math.sin(pC.imag)*Math.exp(pC.real); } //calcula en el objeto la raíz cuadrada de un número positivo o negativo public void csqrt(double pNum){ if(pNum>=0) { real=Math.sqrt(d); imag= 0;} else{ real=0; imag=Math.sqrt(-pNum); } } //traduce un número complejo a un string public String toString(){ if(imag>0) return new String((double)Math.round(100*real)/100+"+“ +(double)Math.round(100*imag)/100+"*i"); else return new String((double)Math.round(100*real)/100+" - “ +(double)Math.round(-100*imag)/100+"*i"); }

COMPLEJOS

94

95

//lee un número complejo public void leerComplejo () throws IOException { BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Real: "); String str = input.readLine(); real = Float.parseFloat(str.trim()); System.out.println("Imaginaria: "); str = input.readLine(); imag = Float.parseFloat(str.trim()); }

d) Máquinas Abstractas de Estado (MAE)
A diferencia de los TADs, las operaciones de una MAE se efectúan sobre un único objeto (la clase), no se pueden generar diferentes objetos del mismo tipo Patrón SINGLETON En Java definiremos MAEs a través de clases que cumplan los siguientes requisitos:
No pueden admitir tener varias instancias Los métodos se aplican sobre el único objeto de la clase
96 97

COMPLEJOS

// imprime un número complejo public void putComplejo(){ System.out.println(this.toString()); }

}

13

package packPilaMae; // Interfaz Pila public interface IPilaMae { public int tamano(); // Devuelve el tamaño de la pila public boolean estaVacia(); // Indica si la pila está vacía

PILA - MAE

package packPilaMae; public class IPilaMae{ PilaMaeArray extends

PILA - MAE
Object implements

// Atributos private final int CAP=1000; private Object[] P; private int tope=-1; //Constructora private PilaMaeArray() { P=new Object[CAP]; } // Inicializadora private static PilaMaeArray pila=new PilaMaeArray(); // Operaciones ... }
99

public Object primero()throws ExcepcionPilaMaeVacia; // Obtiene el primer elemento de la pila public void empilar (Object o) throws ExcepcionPilaMaeLlena; // Empila el primer elemento public Object desempilar () throws // Desempila un elemento }
98

ExcepcionPilaMaeVacia;

... // Operaciones

PILA - MAE

... // Operaciones

PILA - MAE

public static PilaMaeArray obtPilaMae (){ return pila; } public int tamano() {return (tope+1);} public boolean estaVacia() {return (tope<0);} public Object primero()throws ExcepcionPilaMaeVacia { if (estaVacia()) throw new ExcepcionPilaMaeVacia ("vacia"); return P[tope]; } }
100

public void empilar (Object o) throws ExcepcionPilaMaeLlena{ if (tamano()==CAP) throw new ExcepcionPilaMaeLlena("llena"); P[++tope]=o;} public Object desempilar () throws ExcepcionPilaMaeVacia{ Object elem; if (estaVacia()) throw new ExcepcionPilaMaeVacia("vacia"); elem=P[tope]; P[tope--]=null; return elem; }

101

Descomponiendo módulos
Java permite organizar las clases en paquetes y subpaquetes de forma jerárquica Esta jerarquía se refleja en la forma de almacenamiento en disco a través de directorios
java java.lang java.io java.awt Java.awt.peer

Librería de clases
El lenguaje Java tiene una librería muy amplia La librería se organiza en paquetes En Java los paquetes se utilizan para agrupar clases que tienen “algo” en común Antes de implementar una clase en Java comprobar si ya está hecha Un paquete declara: clases, interfaces, excepciones y errores
java.applet java.awt java.lang

Un paquete se puede organizar en subpaquetes (que a su vez son paquetes)
102

java.lang.reflect java.lang

103

14

Paquetes de Java
Paquete: colección de clases que tienen una relación estrecha. Paquetes básicos: java.lang java.io java.util java.net java.awt java.applet
104

Creación de nuevos paquetes
En cada fichero sólo puede existir una clase pública El nombre del fichero debe corresponder con la clase pública que incluye con la extensión .java La primera sentencia del paquete especifica en que paquete se incluye la clase
package nombrePaquete;
105

Organización de programas Java
Estructura de un fichero fuente de Java:
Una sentencia de especificación del paquete (opcional)
package pack1[.pack2[.pack3]];

Resumen de modificadores (II)
Modificadores de clase:
public: accesible desde cualquier clase private: no accesible desde cualquier otra clase package: desde las clases del mismo paquete donde se define esta clase

Sentencias de importación (opcional)
import
pack1[.pack2].(nombreClase|*);

Código de la clase
106

static: ¡Una clase no puede ser static!
108 abstract: no se podrán crear objetos de una clase b t t dá t d l l

Resumen de modificadores (III)
Modificadores de campos:
public: utilizable también desde fuera de la clase

Resumen de modificadores (IV)
Modificadores de métodos:
public: utilizable también desde fuera de la clase

private: sólo desde la clase donde está declarado package: desde las clases del mismo paquete donde se define su clase protected: desde la clase donde está definido, desde todas sus subclases (siendo o no del mismo paquete) y desde todas las clases del mismo paquete
109 static: el campo es de la clase: todos los objetos de

private: sólo desde la clase donde está declarado package: desde las clases del mismo paquete donde se define su clase protected: desde la clase donde está definido, desde todas sus subclases (siendo o no del mismo paquete) y desde todas las clases del mismo paquete static: corresponde a la clase, no a las instancias
110

15

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->