Sei sulla pagina 1di 12

Definición de clases

Para definir una clase se usa la palabra reservada class y el nombre de la misma

class NombreClase {
...
}

Si dicha clase es una subclase de otra, se usa extends para indicar la superclase

class NombreClase extends NombreSuperclase {


...
}

Si dicha clase implementa una interfaz se usa implements para referirse a la


interfaz

class NombreClase implements Interfaz {


...
}

Una clase puede implementar varias interfaces


class NombreClase implements Interfaz1, Interfaz2, Interfaz3, ..., InterfazN {
...
}

Una clase puede ser subclase de otra y además implementar interfaces

class NombreClase extends NombreSuperclase implements Interfaz1, Interfaz2,


Interfaz3, ..., InterfazN {
...
}

Variables locales
Son aquellas que se declaran dentro de la definición de un método
TipoX métodoA ( listaParámetrosFormales ){
TipoY y; // variable local
...
}

Variables de instancia
Las variables de instancia se declaran dentro de la definición de la clase pero
fuera de cualquier método.
class X {
Tipo a; //variable de instancia
...
}
Variables de clase
Las variables de clase son globales para todas sus instancias de clase. Se
declaran poniendo la palabra reservada static antes del tipo de la variable que se
va a declarar.

class X {
static Tipo b; //variable de clase
...
}

Control del acceso a los miembros de la clase


Una de las ventajas de las clases es que se pueden proteger sus variables y métodos
miembros frente al acceso de otros objetos. En java se pueden utilizar los modificadores de
acceso para proteger tanto las variables como los métodos de la clase cuando se declaran.
El lenguaje Java soporta cuatro niveles de acceso para las variables y métodos miembros:
private, protected, public, y (todavía no especificado) acceso a paquete.

Modificador Clase Subclase Paquete Mundo


private x
protected x x x
public x x x x
package * x x

*este es el default no se escribe en la declaración de una variable o método

Ejemplo de definición de una clase

//Punto.java
import java.awt.*;

class Punto {
int x = 0;
int y = 0;

public Punto ( ) {
x=5;
y=5;
}
public Punto (int x, inty ) {
this. x=x;
this. y=y;
}
int obtenX {
return x;
}
int obtenY ( ) {
return y;
}
void ponX (int x) {
this.x=x;
}
void ponY(int y ) {
this.y=y;
}
public void mueve (int dx, int dy ){
x=x+dx;
y=y+dy:
}
public void dibuja (Graphics g ){
g.drawLine (x, y, x, y );
}
}

import Punto;
import java.applet.*;
import java.awt.*;

public class DibujaPunto extends Applet {


Punto p1,p2;
public void init ( ) {
p1 = new Punto ( );
p2 = new Punto (10,10);
}
public void paint (Graphics g){
p1. dibuja (g);
p2. dibuja (g);
}
}

Constructores
El constructor es un método especial que tiene las siguientes características:

1.-Se llama como la clase.


2.-Sirve para inicializar los objetos de la clase.
3-Si hay mas de uno esta sobrecargado.
4.-No regresa valor.
5.-Es llamado por el operador new.
Como llamar a otro constructor
Un constructor puede tener el mismo comportamiento que otro constructor y un
poco más. Si se quiere llamar a un constructor definido en la clase actual se usa
lo siguiente:

this (arg1, arg2, arg3, …)

Como llamar a un constructor en la superclase.


Para llamar a un método ordinario en una superclase, utilice super.nombreMetodo
(argumentos). Para llamar el constructor de la superclase se usa lo siguiente:

super ( arg1, arg2,….)

Esqueleto de un applet simple

import java.applet.*;
import java.awt.*;

public class MiApplet extends Applet{


public void init ( ) {

}
public void paint (Graphics g) {

}
}

El ciclo de vida de un applet

El applet es
cargado start

Dejando una
Visitando una pagina o
init pagina descartandola destroy

stop Descartando una


pagina

ciclo de vida de un applet


Los métodos en el ciclo de vida de un applet y su propósito se muestran a continuación

Método Descripción
void init() Se llama una vez después de que un applet ha sido cargado en el sistema.
Es un buen lugar para cualquier inicialización necesaria. Por ejemplo para
construir la IGU del applet.
void start() Se llama para informar al applet que debe realizar una acción para
empezar a ejecutarse. Este método es llamado después de init y siempre
que el applet es revisitado en una pagina web.
void stop() Se llama para informar al applet que debe detener su ejecución.
Típicamente es llamado cuando la pagina web que contiene este applet es
reemplazada por otra pagina.
void destroy() Se llama para decirle al applet que esta siendo eliminado del sistema y
que este debe destruir cualquier recurso que tenga asignado. Note que
stop se llamara siempre antes de llamar a destroy.

Esqueleto de una aplicación

class ClaseX {
tipoA a;// variable de instancia
static tipoB b;// variable de clase

tipo1 métodoM (listaDeParámetrosFormales){ // método de instancia


tipoC c; // variable local

}
static tipo2 métodoN (listaDeParámetrosFormales){ // método de clase
tipoD d; // variable local

}
public static void main (String args[ ])
{
tipo1 t1; // variable local
tipo2 t2; // variable local

ClaseX unObjetoDeClaseX= new ClaseX();


t1 =unObjetoDeclaseX.métodoM (listaDeParámetrosReales);
t2 =ClaseX.métodoN (listaDeParámetrosReales);
}
}
Superposición de métodos
class ClaseImprime {
int x=0;
int y=1;
void imprime () {
System.out.println (“x es “+x);
System.out.println (“y es “+y);
}
}

class SubclaseImprime extends ClaseImprime{


int z=3;
public static void main (String args[] ){
SubclaseImprime obj=new SubclaseImprime ();
obj.imprime();
}
}

x es 0
y es 1

class SubclaseImprime2 extends ClaseImprime {


int z=3;
public imprime (){
System.out.println (“x es “ + x );
System.out.println (“y es “ + y );
System.out.println (“z es “ + z ):
}
public static void main (String args[] ){
SubclaseImprime2 obj=new SubclaseImprime2 ();
obj.imprime ();
}
}

x es 0
y es 1
z es 3

// de la clase ClaseImprime
void imprime (){
System.out.println(“x es “ + x);
System.out.println(“y es “ + y);
}
// de la clase SubclaseImprime2
void imprime (){
super.imprime ();
System.out.println(“z es “ + z);
}

x es 0
y es 1
z es 3

Clases abstractas
Una clase abstracta no puede crear instancias directas. En java una clase
abstracta es aquella que contiene al menos un método abstracto. Los métodos
abstractos no necesitan implementación; se requiere que las subclases no
abstractas los implementen.

public abstract class MiClaseAbstracta {


int unaVariable;
public abstract int unaSubclaseNoAbstractaDebeImplementarme();
public void hazAlgo(){

}
}

public class UnaSubclaseConcreta extends MiClaseAbstracta {


public abstract int unaSubclaseNoAbstractaDebeImplementarme (){
// debemos implementar este método

}
}

Interfaces en java
Una definición de interfaz es: una interfaz es una declaración de un conjunto de
métodos. Esta no lleva información sobre implementación, así una interfaz no
puede ser implementada directamente. Una clase puede implementar múltiples
interfaces.

public interface unaInterfaz{


public static final int laRespuesta=42;//ok
public abstract int laVidaEnElUniverso();//ok
long contadorDelBingBang=0; //ok
long edadDelUniverso();//ok
protected int unaConstante;
private int obtenUnEntero();
}
Ejemplo de definición y uso de una interfaz

inteface Imprimible {
void imprime();
}

class Lunes implements Imprimible{


void imprime(){
System.out.println(“Lunes”);
}
}

class Martes implements Imprimible{


void imprime(){
System.out.println(“Martes”);
}
}

class Miercoles implements Imprimible{


void imprime(){
System.out.println(“Miercoles”);
}
}

class Jueves implements Imprimible{


void imprime(){
System.out.println(“Jueves”);
}
}

class Viernes implements Imprimible{


void imprime(){
System.out.println(“Viernes”);
}
}

Notación UML para interfaces

Nombre Interfaz

Clase <<interfaz>>
Clase
Implementadora Tipo
Implementadora
Ejemplos

Imprimible
<<interfaz>>
Imprimible
Lunes
Lunes Imprime():void

Interfaces de elementos soportados por la clase java.awt.Component

public interface EventListener {


}
public interface MouseListener extends EventListener {
public abstract void mouseClicked(MouseEvent e);
public abstract void mouseEntered(MouseEvent e);
public abstract void mouseExited(MouseEvent e);
public abstract void mousePressed(MouseEvent e);
public abstract void mouseReleased(MouseEvent e);
}

public interface ActionListener extends java.util.EventListener


{
void actionPerformed (ActionEvent e);
}

si un objeto quiere recibir notificaciones de eventos del ratón debe de llamar el


siguiente método

public void addMouseListener(MouseListener listener);

Si un objeto quiere recibir notificaciones de eventos acción se debe registrar


llamando el siguiente método

public void addActionListener(ActionListener listener);

Paquetes
Los paquetes son la manera de Java para diseñar y organizar a gran escala.
Además de las clases que nos permiten agrupar los campos y métodos, Java tiene
una construcción llamada paquete que permite agrupar clases relacionadas.
Clases seleccionadas de este paquete pueden ser usadas por otras clases que no
estén en el paquete mediante el uso del comando import. Suponga que
quisiéramos crear un paquete de clases geométricas relacionadas que
llamaremos el paquete forma. Podemos hacerlo usando un archivo por clase y
poniendo una declaración package forma al principio de cada archivo.

//Forma.java
package forma;
class Forma {
...
}
---------------------------------------
//Punto.java
package forma;
class Punto extends Forma {

}
---------------------------------------
//Línea.java
package forma;
class Linea extends Forma {

}
---------------------------------------
//Triangulo.java
package forma;
class Triangulo extends Forma{

}
---------------------------------------
//Rectángulo.java
package forma;
class rectángulo extends Forma {

}
---------------------------------------
//Circulo.java
package forma;
class Circulo extends Forma{

}
---------------------------------------
//Elipse.java
package forma;
class Elipse extends Forma{

}
---------------------------------------
//Dibuja. Java
//importamos el paquete forma para usarlo
import forma.*;
...
Excepciones
Una forma de manejar los errores en los lenguajes como C era regresar un valor
para decirle al llamador de la función que un error ocurrió. Así siempre que una
función tenia la posibilidad de regresar un código de error, tenia que checarse y
una acción apropiada tenia que ser tomada, como en la siguiente pieza de código:

if(!escribirArchivo (algo)){
/*error*/
}
if(!escribirArchivo (algoMas)){
/*error*/
}

Las excepciones proveen una forma limpia para que un método aborte lo que sea
que este haciendo y señale al llamador del método que algo salió mal. En
contraste con las formas de manejo de error que devuelven códigos de error, el
llamador puede ignorar la excepción que fue lanzada y dejar que el error se
propague hacia arriba en la pila de llamadas hasta que alguno de los métodos
maneje la excepción. Suponga que existe un método llamado escribe algo que
usa retorno de códigos de error.

void escribeAlgo (String algo, String algoMás) {


if(! escribirArchivo(algo)){
/*error*/
return;
}
if(!escribirArchivo(algoMás)){
/*error*/
return;
}
}

Si se escribe dicho método usando excepciones y suponiendo que escribeArchivo


lanzara una excepción.

void escribeAlgo(String algo, String algoMás){


try{
escribirArchivo(algo);
escribirArchivo(algomás);
}catch (excepción e ){
e. printStackTrace();
return;
}
}

Las instrucciones dentro del bloque try se escriben como si no ocurrieran


excepciones. Si una excepción ocurre en cualquier parte del bloque try, las
instrucciones del bloque catch se ejecutan.

Para lanzar una excepción, se usa el operador throw en Java. El argumento para
este operador es una instancia de una subclase de la clase Exception.

void escribirArchivo (String algo){


if (archivoNoExiste){
throw new FileNotFoundException();
} else{
/* escribir algo al archivo */
}
}

La instrucción throw aborta el método y lanza la excepción a lo largo de la pila de


llamadas. Si hay una instrucción catch en el llamador que concuerde con la clase
de la excepción o una de sus clases ancestros, entonces la excepción se detiene
ahí y la instrucción catch manejara el problema. Sin embargo si el llamador no
tiene una instrucción catch, la excepción continua viajando a lo largo de la pila
hasta que encuentra una instrucción catch. El programa aborta si no hay ninguna
instrucción catch.

excepción
escribirArchivo
escribeAlgo
pila de manejador de
llamadas
escribeTodo excepciones

Lo que pasa cuando se lanza una excepción.