Import paquete paquet clase; import



Descargar 32,42 Kb.
Fecha de conversión24.03.2017
Tamaño32,42 Kb.

Paquetes e interfaces



Paquetes


Los paquetes son recipientes con clases que se utilizan para mantener el espacio de clase dividido en compartimentos. Por ejemplo un paquete puede tener una clase llamada lista, que se puede almacenar en un paquete propio sin preocuparte por conflictos con otra clase llamada lista escrita por otra persona. El paquete tendrá que estar almacenado en un directorio con el mismo nombre que la clase creada.

package java.awt.imagen;
La sentencia import se utiliza para utilizar las clases o paquetes enteros sin tener que escribir esas clases. También se puede utilizar el asterisco (*) para buscar en el paquete completo sin tener que especificar cada una de las clases.

import paquete.paquete2.clase;

import paquete.paquete2.*;
Con Java vienen implementadas varios paquetes para realizar operaciones específicas, como operaciones matemáticas, gráficos, imágenes, etc ...
Todas las clases incorporadas en Java están almacenadas en directorios independientes. La clase java.lang es la única que se importa automáticamente. El resto, en caso de que sean necesarias las tendremos que importar.
El uso de paquetes facilita el uso, manejo y mantenimiento de las aplicaciones generadas con Java. Su mecanismo puede utilizarse para varios propósitos:

  • organizar archivos cuyo código fuente está relacionado

  • evitar conflicto entre nombres de tipo

  • proporcionar encapsulado y control de acceso a nivel de paquete

Si se pone la declaración package algunPaquete; al principio de un archivo de código fuente de Java, éste será parte de algunPaquete. Todos los tipos (clases e interfaces) definidos aquí se unen al paquete especificado. Solo se permite una declaración package en el archivo. Pero varios archivos del mismo sistema local pueden pertenecer al mismo paquete y su declaración sólo hace que todo nombre de tipo definido en el archivo vaya antecedido implícitamente con la denominación del paquete: algunPaquete.NombreTipo


La manera más fácil de compilar el código en un paquete es ir al directorio padre y emplear el comando:

javac algunPaquete /*.java


y para ejecutar algún archivo se puede hacer:

java algunPaquete /algunaClase


Al incorporar las clases de más de un paquete puede ocurrir que haya nombres de clases iguales; para que no haya ambigüedad en este caso hay que preceder del nombre del paquete al nombre de la clase. Por ejemplo:

java.util.Random r=new java.util.Random();


Algunos de los paquetes integrados a Java:

  • java.lang - contiene clases esenciales para el lenguaje Java:

  • para programación: String, Object, Math, Class, Thread, System, clase de envoltura de tipo y las interfaces Cloneable y Runnable

  • para operaciones de lenguaje: Compiler, Runtime t SecurityManager

  • para error y excepciones: Exception, throwable, entre otras clases

  • java.applet - permite a través de la clase Applet la creación de applets proporcionando interfaces para conectarlos con su documento web.

  • java.awt – ofrece un juego de herramientas abstracto de ventanas (AWT, Abstract Window Toolkit) para la programación en GUI y para la creación y manipulación de imágenes. Independientemente de la plataforma

  • java.io – soporta flujos de entrada y salida de Java

  • java.math – para cálculos enteros y cifras grandes con punto flotante

  • java.net - soporte a redes: URLs, conexiones TCP, UDP, direcciones IP y conversiones de binario a texto

  • java.rmi - invocación a métodos remotos para programas de Java

  • java.util - contiene varias clases de utilerias: conjunto de bits, enumeración, contenedores genéricos (Vector y Hashtable), hora, fecha, separación de ficha, generación de números aleatorios, propiedades del sistema

  • org.omg.CORBA – contiene varias clases utilizadas para la generación de objetos CORBA que podrán ser invocados de manera remota.

Ejemplos:

-Crear una carpeta con el nombre de uno, esta carpeta es el paquete uno

-Dentro de la carpeta uno crear las clases siguientes:

package uno;
public class A1
{public void aa()
{System.out.println("metodo aa de la clase A1 del paquete uno");}
}

grabar  A1.java


package uno;
public class A2
{public void aaaa()
{System.out.println("metodo aaaa de la clase A2 del paquete uno");}
}

grabar  A2.java


-Compilar los archivos, si se compila desde la consola del MS-DOS, y desde la carpeta que contiene a este paquete, se hará de la manera siguiente: javac uno/*.java con esto compila todas las clases que se encuentran en el paquete uno.
-Crear una carpeta con el nombre de dos, esta carpeta es el paquete dos

-Dentro de la carpeta uno crear las clases siguientes:

package dos;
public class B1
{public void bb()
{System.out.println("metodo bb de la clase B1 del paquete dos");}
}

grabar  B1.java


package dos;
public class B2
{public void bbbb()
{System.out.println("metodo bbbb de la clase B2 del paquete uno");}
}

grabar  B2.java


-Compilar los archivos, si se compila desde la consola del MS-DOS, y desde la carpeta que contiene a este paquete, se hará de la manera siguiente: javac dos/*.java con esto compila todas las clases que se encuentran en el paquete uno.
-En la carpeta donde estén contenidos los paquetes editar la clase siguiente

import uno.*;


import dos.*;
public class UsoPaquetes
{public static void main(String arg[])
{A1 a=new A1();
A2 a2=new A2();
B1 b=new B1();
B2 b2=new B2();
a.aa();
a2.aaaa();
b.bb();
b2.bbbb();
}
}

grabar  UsoPaquetes.java


-Compilarla y ejecutarla
Interfaces
Conjunto de métodos abstractos y de constantes publicas definidos en un archivo .java. Una interface es similar a una clase abstracta llevada al límite en que sus métodos son abstractos, pero no hay que confundirnos pensando que son lo mismo, ya que en una clase abstracta si podemos tener la combinación de métodos abstractos y métodos concretos (ya implementados o definidos) y en una interface no, todos los métodos que la conforman siempre van a ser abstractos.

Su finalidad es definir el formato que deben tener determinados métodos que han de implementar ciertas clases.

Las interfaces de Java están diseñadas para admitir resolución de métodos dinámicamente durante la ejecución. Para que un método sea llamado desde una clase a otra, ambas clases tienen que estar presente durante la compilación. Las interfaces son como las clases, pero sin variables de instancia y con métodos declarados sin cuerpo. Cuando se declara una interfaz no se hacen suposiciones acerca de los detalles de la implementación. Las clases pueden implementar varias interfaces. Las interfaces están en una jerarquía distinta a la de las clases por lo que es posible que varias clases que no tengan la mas mínima relación en cuanto a la jerarquía de clases implementen la misma interface.
En una interface no se establece lo que un método tiene que hacer y cómo hacerlo, sino el formato que éste debe tener (cabecera).
Todos los métodos definidos en una interface son públicos y abstractos aunque no se indique explícitamente, cuando una clase implementa los métodos de una interface, si debe agregar el modificado public en el método aunque no este indicado en la interface.
Es posible definir variables finales (constantes) las cuales implícitamente son publicas y estaticas, por lo que no es necesario indicarlo en su declaración.
Cuando una clase implementa una interface, está obligada a implementar todos sus métodos, si no es así, se convierte en una clase abstracta y por lo tanto tendrá que declararse así anteponiendo al inicio de la cabecera de la misma la palabra abstract.

Una clase puede implementar más de una interface. También puede heredar una clase e implementar una o varias interfaces.


Una interface puede heredar de otras interfaces

interface sub extends intereface1, interface2, …..


Ejemplo:

interface uno


{void a();}
grabar  uno.java
interface dos
{void b();}
grabar  dos.java
interface tres
{int c(char x);}
grabar  tres.java
public interface hereda extends uno,dos,tres
{void d();}
grabar  hereda.java
public class implementa implements hereda
{public void a()
{System.out.println("metodo a");}
public void b()
{System.out.println("metodo b");}
public int c(char x)
{System.out.println("metodo c");
return (int)x;
}
public void d()
{System.out.println("metodo d");}
public static void main(String arg[])
{implementa obj=new implementa();
obj.a();
obj.b();
System.out.println(obj.c('p'));
obj.d();
}
}

grabar  implementa.java


Definición de una interface

interface nombre

{ public tipo_devuelto nombre_metodo ([parametros]); // siempre deben ser public y abstractos, por definición ya lo son por lo que

// no es necesario indicarlo en la declaración

final tipo_dato nombre_variable_final=valor; //siempre deben ser final (valor constante)

}
Se utiliza la sentencia implements para cuando se desea implementar una interface. Una clase que implementa algunas interfaces tienen la forma general:

class nomb_clase [extends superclaes] implements interface1 [, interface2, ..]

{.....


aquí se implementa él o los métodos que fueron definidos en el archivo que contiene a la interface (lo nombrare archivo interface)

public tipo_devuelto nombre_metodo ([parametros]) // declaracion que se hizo en el archivo interface

{cuerpo del método}

}

Se pueden declarar variables como referencias a objetos que utilizan una interface como tipo en vez de una clase. Cualquier instancia de una clase que implementa la interface declarada se puede almacenar en una variable de ese tipo. Si se desea llamará un método a través de una de estas variables, se llamará a la implementación correcta en base a la instancia actual.


Una variable de tipo interface puede almacenar cualquier objeto de las clases que la implementan, pudiendo utilizar esta variable para invocar métodos del objeto que han sido declarados en la interface e implementados en la clase.
Operaciones op=new Tringulo();
Ejemplo1:
Se define la interface:
public interface ejemplo

{public char get(); // se define la cabeza del metodo que forma parte de la interface ejemplo



public void put(char x); // se define la cabeza del metodo que forma parte de la interface ejemplo

}
grabar como: ejemplo.java

compilar: javac ejemplo.java
Se hace la clase donde se utiliza (implementa) la interface ejemplo
import java.io.*;

public class ejemploINterface implements ejemplo

{public char get() //metodo de la interface, se desarrolla el método de acuerdo las necesidades de este programa

{try


{return (char) System.in.read();}

catch (IOException e)

{return '*';}

}
public void put(char x) //metodo de la interface, se desarrolla el método de acuerdo las necesidades de este programa

{imprime("------> "+x+" <------");}
static void imprime(String cad)//metodo de la clase ejemploINterface

{System.out.println(cad);}


public static void main(String arg[])

{char x;


ejemploINterface obj=new ejemploINterface();

imprime("Dame un caracter");

x=obj.get();

obj.put(x);

}

}
grabar: ejemploINterface.java



compilar: javac ejemploINterface.java

ejecutar: java ejemploINterface


Ejemplo2

public class Ejemplo_Interface implements interfaz


{static void imprime(String msg)
{System.out.println(msg);}

//implementacion de los metodos de la interfaz


public int multiplicacion(int a,int b)
{return a*b;}
public int division(int a,int b)
{return a/b;}

public static void main(String arg[])


{Ejemplo_Interface obj=new Ejemplo_Interface ();
imprime("la multiplicacion de 3 * 2 es="+obj.multiplicacion(3,2));
imprime("la division de 3 / 2 es="+obj.division(3,2));
}
}

interface interfaz


{int multiplicacion(int a,int b);
int division(int a,int b);
}


maria eugenia puga nathal Página 24/03/2017


La base de datos está protegida por derechos de autor ©absta.info 2016
enviar mensaje

    Página principal