Composición

prev.gif (997 bytes)chapter.gif (1105 bytes)home.gif (1054 bytes)next.gif (998 bytes)

Clases y objetos

La clase Punto

La clase Rectangulo

Objetos de la clase Rectangulo


Hay dos formas de reutilizar el código, mediante la composición y mediante la herencia. La composición significa utlizar objetos dentro de otros objetos. Por ejemplo, un applet es un objeto que contiene en su interior otros objetos como botones, etiquetas, etc. Cada uno de los controles está descrito por una clase.

Vamos a estudiar una nueva aproximación a la clase Rectangulo definiendo el origen, no como un par de coordenadas x e y (números enteros) sino como objetos de una nueva clase denominada Punto.

disco.gif (1035 bytes)rectangulo: Punto.java, Rectangulo.java, RectanguloApp.java

 

La clase Punto

La clase Punto tiene dos miembros dato, la abscisa x y la ordenada y de un punto del plano. Definimos dos constructores uno por defecto que sitúa el punto en el origen, y otro constructor explícito que proporciona las coordenadas x e y de un punto concreto.

public class Punto {
    int x;
    int y; 
//funciones miembro
}

El constructor explícito de la clase Punto podemos escribirlo de dos formas

  public Punto(int x1, int y1) {
        x = x1;
	y = y1;
  }

Cuando el nombre de los parámetros es el mismo que el nombre de los miembros datos escribimos

  public Punto(int x, int y) {
        this.x = x;
	this.y = y;
  }

this.x que está a la izquierda y que recibe el dato x que se le pasa al constructor se refiere al miembro dato, mientras que x que está a la derecha es el parámetro. this es una palabra reservada que guarda una refrencia al objeto propio, u objeto actual. Tendremos ocasión a lo largo del curso de encontrar esta palabra en distintas situaciones.

La función miembro desplazar simplemente cambia la posición del punto desde (x, y) a (x+dx, y+dy). La función desplazar cuando es llamada recibe en sus dos parámetros dx y dy el desplazamiento del punto y actualiza las coordenadas x e y del punto. La función no retorna ningún valor

  public void desplazar(int dx, int dy){
    	x+=dx;
    	y+=dy;
  }

Para crear un objeto de la clase Punto cuyas coordenadas x e y valgan repectivamente 10 y 23 escribimos

	Punto p=new Punto(10, 23);

Para desplazar el punto p 10 unidades hacia la izquierda y 40 hacia abajo, llamamos desde el objeto p a la función desplazar y le pasamos el desplazamiento horizontal y vertical.

	p.desplazar(-10, 40);

El código completo de la clase Punto, es el siguiente

public class Punto {
    int x = 0;
    int y = 0;
  public Punto(int x, int y) {
        this.x = x;
	this.y = y;
  }
  public Punto() {
    	x=0;
    	y=0;
  }
  void desplazar(int dx, int dy){
    	x+=dx;
    	y+=dy;
  }
}

 

La clase Rectangulo

La clase Rectangulo tiene como miembros dato, el origen que es un objeto de la clase Punto y las dimensiones ancho y alto.

public class Rectangulo {
    Punto origen;
    int ancho ;
    int alto ;
//funciones miembro
}

El constructor por defecto, crea un rectángulo situado en el punto 0,0 y con dimensiones nulas

    public Rectangulo() {
	    origen = new Punto(0, 0);
	    ancho=0;
	    alto=0;
    }

El constructor explícito crea un rectángulo situado en un determinado punto p y con unas dimensiones que se le pasan en el constructor

    public Rectangulo(Punto p, int w, int h) {
	    origen = p;
	    ancho = w;
	    alto = h;
    }

Podemos definir otros constructores en términos del constructor explícito usando la palabra reservada this.

    public Rectangulo(Punto p) {
	    this(p, 0, 0);
    }
    public Rectangulo(int w, int h) {
	    this(new Punto(0, 0), w, h);
    }

El primero crea un rectángulo de dimensiones nulas situado en el punto p. El segundo, crea un rectángulo de unas determinadas dimensiones situándolo en el punto 0, 0. Dentro del cuerpo de cada constructor se llama al constructor explícito mediante this pasándole en sus parámetros los valores apropiados.

Para desplazar un rectángulo, trasladamos su origen (esquina superior izquierda) a otra posición, sin cambiar su anchura o altura. Desde el objeto origen, llamamos a la función desplazar miembro de la clase Punto

    void desplazar(int dx, int dy) {
	origen.desplazar(dx, dy);
    }

El código completo de la nueva clase Rectangulo, es el siguiente.

public class Rectangulo {
      Punto origen;
      int ancho ;
      int alto ;

    public Rectangulo() {
	    origen = new Punto(0, 0);
	    ancho=0;
	    alto=0;
    }
    public Rectangulo(Punto p) {
	    this(p, 0, 0);
    }
    public Rectangulo(int w, int h) {
	    this(new Punto(0, 0), w, h);
    }
    public Rectangulo(Punto p, int w, int h) {
	    origen = p;
	    ancho = w;
	    alto = h;
    }   
    void desplazar(int dx, int dy) {
	    origen.desplazar(dx, dy);
    }
    int calcularArea() {
	    return ancho * alto;
    }
}

 

Objetos de la clase Rectangulo

Para crear un rectángulo rect1 situado en el punto (0, 0) y cuyas dimensiones son 100 y 200 escribimos

        Rectangulo rect1=new Rectangulo(100, 200);

Para crear un rectángulo rect2, situado en el punto de coordenadas 44, 70 y de dimensiones nulas escribimos

        Punto p=new Punto(44, 70);
	Rectangulo rect2=new Rectangulo(p);

O bien, en una sóla línea

        Rectangulo rect2=new Rectangulo(new Punto(44, 70));

Para desplazar el rectángulo rect1 desde el punto (100, 200) a otro punto situado 40 unidades hacia la derecha y 20 hacia abajo, sin modificar sus dimensiones, escribimos

        rect1.desplazar(40, 20);

Para hallar y mostrar el área del rectángulo rect1 podemos escribir

        System.out.println("el área es "+rect1.calcularArea());

Para hallar el área de un rectángulo de 100 unidades de largo y 50 de alto y guardar el resultado en la variable entera areaRect, escribimos en una sóla línea.

        int areaRect=new Rectangulo(100, 50).calcularArea();
public class RectanguloApp {
    public static void main(String[] args) {
        Rectangulo rect1=new Rectangulo(100, 200);
        Rectangulo rect2=new Rectangulo(new Punto(44, 70));
        Rectangulo rect3=new Rectangulo();
        rect1.desplazar(40, 20);
        System.out.println("el área es "+rect1.calcularArea());
        int areaRect=new Rectangulo(100, 50).calcularArea();
        System.out.println("el área es "+areaRect);
        }
    }
}