8 Paquetes e Interfaces

1 Paquetes

Un paquete es un contenedor de clases, que se usa para mantener el espacio de nombres de clase, dividido en compartimentos.

• Se almacenan de manera jerárquica: Java usa los directorios del sistema de archivos para almacenar los paquetes

  Ejemplo: Las clases del paquete MiPaquete (ficheros .class y .java) se almacenarán en directorio MiPaquete

• Se importan explícitamente en las definiciones de nuevas clases con la sentencia

  import nombre-paquete;
  

• Permiten restringir la visibilidad de las clases que contiene:

  Se pueden definir clases en un paquete sin que el mundo exterior sepa que están allí.

• Se pueden definir miembros de una clase, que sean sólo accesibles por miembros del mismo paquete

1 Definición de un paquete

Incluiremos la siguiente sentencia como primera sentencia del archivo fuente .java

package nombre-paquete

• Todas las clases de ese archivo serán de ese paquete
• Si no ponemos esta sentencia, las clases pertenecen al paquete por defecto
• Una misma sentencia package puede incluirse en varios archivos fuente
• Se puede crear una jerarquía de paquetes: package paq1[.paq2[.paq3]];
  Ejemplo: java.awt.image

2 La variable de entorno CLASSPATH

Supongamos que construimos la clase PaquetePrueba perteneciente al paquete prueba, dentro del fichero PaquetePrueba.java (directorio prueba)

• Compilación: Situarse en directorio prueba y ejecutar

  javac -bootclasspath $CLDC_PATH/common/api/classes 
        -d tmpclasses prueba/PaquetePrueba.java
  

• Preverificación

  preverify -classpath $CLDC_PATH/common/api/classes:tmpclasses 
        -d . prueba/PaquetePrueba
  

  o bien

  preverify -classpath $CLDC_PATH/common/api/classes:tmpclasses 
        -d . tmpclasses
  

• Ejecución: Situarse en directorio padre de prueba y ejecutar

  kvm -classpath . prueba.PaquetePrueba
  

  o bien añadir directorio padre de prueba a CLASSPATH y ejecutar

  kvm prueba.PaquetePrueba
  

3 Ejemplo de paquete: P25/MyPack

package MyPack;

class Balance {
  String name;
  double bal;

  Balance(String n, double b) {
    name = n;
    bal = b;
  }
  void show() {
    if(bal<0)
      System.out.print("-->> ");
    System.out.println(name + ": $" + bal);
  }
}

class AccountBalance {
  public static void main(String args[]) {
    Balance current[] = new Balance[3];

    current[0] = new Balance("K. J. Fielding", 123.23);
    current[1] = new Balance("Will Tell", 157.02);
    current[2] = new Balance("Tom Jackson", -12.33);
    for(int i=0; i<3; i++) current[i].show();
  }
}

2 Protección de acceso

Las clases y los paquetes son dos medios de encapsular y contener el espacio de nombres y el ámbito de las variables y métodos.

• Paquetes: Actúan como recipientes de clases y otros paquetes subordinados.
• Clases: Actúan como recipientes de datos y código.

1 Tipos de acceso a miembros de una clase

Desde método en ...	private	sin modif.	protected	public
misma clase	sí	sí	sí	sí
subclase del mismo paquete	no	sí	sí	sí
no subclase del mismo paquete	no	sí	sí	sí
subclase de diferente paquete	no	no	sí	sí
no subclase de diferente paquete	no	no	no	sí

2 Tipos de acceso para una clase

• Acceso por defecto: Accesible sólo por código del mismo paquete
• Acceso public: Accesible por cualquier código

Ejemplo: P26 Ejemplo: P26

package p1;
public class Protection {
  int n = 1;
  private int n_pri = 2;
  protected int n_pro = 3;
  public int n_pub = 4;
  public Protection() {
    System.out.println("constructor base ");
    System.out.println("n = " + n);
    System.out.println("n_pri = " + n_pri);
    System.out.println("n_pro = " + n_pro);
    System.out.println("n_pub = " + n_pub);
  }
}
class Derived extends Protection {
  Derived() {
    System.out.println("constructor de Derived");
    System.out.println("n = " + n);
//  System.out.println("n_pri = " + n_pri);
    System.out.println("n_pro = " + n_pro);
    System.out.println("n_pub = " + n_pub);
  }
}
class SamePackage {
  SamePackage() {
    Protection p = new Protection();
    System.out.println("constructor de SamePackage");
    System.out.println("n = " + p.n);
//  System.out.println("n_pri = " + p.n_pri);
    System.out.println("n_pro = " + p.n_pro);
    System.out.println("n_pub = " + p.n_pub);
  }
}

package p2;

class Protection2 extends p1.Protection {
  Protection2() {
    System.out.println("constructor de Protection2");
//  System.out.println("n = " + n);
//  System.out.println("n_pri = " + n_pri);
    System.out.println("n_pro = " + n_pro);
    System.out.println("n_pub = " + n_pub);
  }
}
class OtherPackage {
  OtherPackage() {
    p1.Protection p = new p1.Protection();
    System.out.println("other package constructor");
//  System.out.println("n = " + p.n);
//  System.out.println("n_pri = " + p.n_pri);
//  System.out.println("n_pro = " + p.n_pro);
    System.out.println("n_pub = " + p.n_pub);
  }
}

3 Importar paquetes

Todas las clases estándar de Java están almacenadas en algún paquete con nombre. Para usar una de esas clases debemos usar su nombre completo. Por ejemplo para la clase Date usaríamos java.util.Date. Otra posibilidad es usar la sentencia import.

• import: Permite que se puedan ver ciertas clases o paquetes enteros sin tener que introducir la estructura de paquetes en que están incluidos, separados por puntos.
• Debe ir tras la sentencia package:

  import paquete[.paquete2].(nombre_clase|*);
  

• Al usar * especificamos que se importa el paquete completo. Esto incrementa el tiempo de compilación, pero no el de ejecución.
• Las clases estándar de Java están dentro del paquete java.
• Las funciones básicas del lenguaje se almacenan en el paquete. java.lang, el cual es importado por defecto.
• Al importar un paquete, sólo están disponibles los elementos públicos de ese paquete para clases que no sean subclases del código importado.

Ejemplo: P27
MyPack/Balance.java

package MyPack;
/* La clase Balance, su constructor, y su metodo show()
   deben ser públicos. Esto significa que pueden ser utilizados por
   código que no sea una subclase y esté fuera de su paquete.
*/
public class Balance {
  String name;
  double bal;
  public Balance(String n, double b) {
    name = n;
    bal = b;
  }

  public void show() {
    if(bal<0)
      System.out.print("-->> ");
    System.out.println(name + ": $" + bal);
  }
}

TestBalance.java

import MyPack.*;
class TestBalance {
  public static void main(String args[]) {
    /* Como Balance es pública, se puede utilizar la
       clase Balance y llamar a su constructor. */
    Balance test = new Balance("J. J. Jaspers", 99.88);
    test.show(); // también se puede llamar al metodo show()
  }
}

4 Interfaces

Son sintácticamente como las clases, pero no tienen variables de instancia y los métodos declarados no contienen cuerpo.

• Se utilizan para especificar lo que debe hacer una clase, pero no cómo lo hace.
• Una clase puede implementar cualquier número de interfaces.

1 Definición de una interfaz

Una interfaz se define casi igual que una clase:

acceso interface nombre {
  tipo_devuelto método1(lista_de_parámetros);
  tipo_devuelto método2(lista_de_parámetros);
  tipo var_final1=valor;
  tipo var_final2=valor;
// ...
  tipo_devuelto métodoN(lista_de_parámetros);
  tipo var_finalN=valor;
}

• acceso puede ser public o no usarse.
  • Si no se utiliza (acceso por defecto) la interfaz está sólo disponible para otros miembros del paquete en el que ha sido declarada.
  • Si se usa public, puede ser usada por cualquier código (todos los métodos y variables son implícitamente públicos).
• Los métodos de una interfaz son básicamente métodos abstractos (no tienen cuerpo de implementación).
• Un interfaz puede tener variables pero serán implícitamente final y static.

Ejemplo definición de interfaz

interface Callback {
  void callback(int param);
}

2 Implementación de una interfaz

• Para implementar una interfaz, la clase debe implementar todos los métodos de la interfaz. Se usa la palabra reservada implements.
• Una vez declarada la interfaz, puede ser implementada por varias clases.
• Cuando implementemos un método de una interfaz, tiene que declararse como public.
• Si una clase implementa dos interfaces que declaran el mismo método, entonces los clientes de cada interfaz usarán el mismo método.

Ejemplo de uso de interfaces: P28

class Client implements Callback {
  public void callback(int p) {
    System.out.println("callback llamado con " + p);
  }
  void nonIfaceMeth() {
    System.out.println("Las clases que implementan interfaces " +
                       "además pueden definir otros miembros.");
  }
}
class TestIface {
  public static void main(String args[]) {
    Callback c = new Client();
    c.callback(42);
  }
}

3 Acceso a implementaciones a través de referencias de la interfaz

• Se pueden declarar variables usando como tipo un interfaz, para referenciar objetos de clases que implementan ese interfaz.
• El método al que se llamará con una variable así, se determina en tiempo de ejecución.

Ejemplo

class TestIface {
  public static void main(String args[]) {
    Callback c = new Client();
    c.callback(42);
  }
}

• Con estas variables sólo se pueden usar los métodos que hay en la interfaz.

Otro ejemplo: P29

// Otra implementación de  Callback.
class AnotherClient implements Callback {
  public void callback(int p) {
    System.out.println("Otra versión de callback");
    System.out.println("El cuadrado de p es " + (p*p));
  }
}

class TestIface2 {
  public static void main(String args[]) {
    Callback c = new Client();
    AnotherClient ob = new AnotherClient();
    c.callback(42);
    c = ob; // c hace referencia a un objeto AnotherClient
    c.callback(42);
  }
}

4 Implementación parcial

• Si una clase incluye una interfaz, pero no implementa todos sus métodos, entonces debe ser declarada como abstract.

5 Variables en interfaces

• Las variables se usan para importar constantes compartidas en múltiples clases.
• Si una interfaz no tiene ningún método, entonces cualquier clase que incluya esta interfaz no tendrá que implementar nada.

Ejemplo: P30/AskMe.java

import java.util.Random;
interface SharedConstants {
  int NO = 0;
  int YES = 1;
  int MAYBE = 2;
  int LATER = 3;
  int SOON = 4;
  int NEVER = 5;
}
class Question implements SharedConstants {
  Random rand = new Random();
  int ask() {
    int prob = (int) (100 * rand.nextDouble());
    if (prob < 30) return NO;         // 30%
    else if (prob < 60) return YES;   // 30%
    else if (prob < 75) return LATER; // 15%
    else if (prob < 98) return SOON;  // 13%
    else return NEVER;                // 2%
  }
}

class AskMe implements SharedConstants {
  static void answer(int result) {
    switch(result) {
      case NO:
        System.out.println("No"); break;
      case YES:
        System.out.println("Si"); break;
      case MAYBE:
        System.out.println("Puede ser"); break;
      case LATER:
        System.out.println("Mas tarde"); break;
      case SOON:
        System.out.println("Pronto"); break;
      case NEVER:
        System.out.println("Nunca"); break;
    }
  }
  public static void main(String args[]) {
    Question q = new Question();
    answer(q.ask());
    answer(q.ask());
    answer(q.ask());
    answer(q.ask());
  }
}

6 Las interfaces se pueden extender

• Una interfaz puede heredar otra utilizando la palabra reservada extends.
• Una clase que implemente una interfaz que herede de otra, debe implementar todos los métodos de la cadena de herencia.

Ejemplo: P31/IFExtend.java

interface A {
  void meth1();
  void meth2();
}
interface B extends A {
  void meth3();
}
class MyClass implements B {
  public void meth1() {
    System.out.println("Implemento meth1().");
  }
  public void meth2() {
    System.out.println("Implemento meth2().");
  }
  public void meth3() {
    System.out.println("Implemento meth3().");
  }
}
class IFExtend {
  public static void main(String arg[]) {
    MyClass ob = new MyClass();
    ob.meth1();
    ob.meth2();
    ob.meth3();
  }
}