INSTITUTO TECNOLOGICO DE TEHUACAN

Ingeniería en sistemas computacionales

Curso de apoyo a la titulaciónCLASES DE JAVA

Diciembre de 2008

CONTENIDO

• Clases• Referencia a objeto• Variables de instancia• Operador new• Operador punto• Declaración de métod

o• Llamada a método

• this• Herencia• super• final• finalize

Clase

• Elemento básico de la programación orientada a objetos (Java)

• Define la forma y comportamiento de un objeto. • Cualquier concepto que desee representar en su

programa en Java está encapsulado en una clase.• Las clases de Java no necesitan el método main. Sólo lo

utiliza el intérprete para decidir dónde comenzar la ejecución.

class Point {}

Forma general de una clase

class nombre_de_clase extends nombre_de_superclase { type variable_de_instancial; type variable_de_instancia2; type variable_de_instanciaN; type nombre_de_métodol (lista_de_parámetros) {

cuerpo_del_método; } type nombre_de_método2 (lista_de_parámetros) {

cuerpo_del_método; } type nombre_de_método3 (lista_de_parámetros) {

cuerpo_del_método; }}

Referencias a objeto (1)

• Los tipos describen el tamaño y comportamiento de los valores y variables.

• Cada nueva clase que se crea añade otro tipo que se puede utilizar igual que los tipos simples.

• Cuando se declara una nueva variable, se puede utilizar un nombre de clase como tipo.

• A estas variables se las conoce como referencias a objeto.

Referencias a objeto (2)

• Todas las referencias a objeto son compatibles también con las instancias de subclases de su tipo declarado.

• Una instancia es una copia individual de la plantilla de la clase, con su propio conjunto de datos llamado variables de instancia.

• A cada instancia se le puede llamar también objeto.

Point p;

Variables de instancia

• Los datos se encapsulan dentro de una clase declarando las variables dentro de las llaves de apertura y cierre de la declaración de la clase.

• A las variables que se declaran en este ámbito se las conoce como variables de instancia.

• Se declaran exactamente igual que las variables locales, a excepción de que se declaran fuera del ámbito de un método en concreto, como el main.

class Point { int x, y;}

Operador new• Crea una única instancia de una clase y devuelve una referencia a

ese objeto. • Este es un ejemplo de la creación de una nueva instancia de Point

y que se almacena en una variable p.

Point p = new Point();

class TwoPoints {public static void main(String args[]) {

Point p1 = new Point();Point p2 = new Point();

p1.x = 10;p1.y = 20;p2.x = 42;p2.y = 99;System.out.println("x = " + pl.x + " y = " + pl.y);System.out.println("x = “ + p2.x + " y = " + p2.y);

}}

Operador punto (.)

• Se utiliza para acceder a las variables de instancia y los métodos contenidos en un objeto. Esta es la forma general de acceder a las variables de instancia utilizando el operador punto.

referencia_a_objeto.nombre_de_variable

class Point {int x, y;

public static void main(String args[])Point p = new Point();p.x = 10;p.y = 20;System.out.println("x = " + p.x + " y = " + p.y);}

}

Declaración de método (1)

• Un método es la interfaz funcional de una clase. • Los métodos son subrutinas unidas a una

definición de clase específica. • Se declaran dentro de una definición de clase al

mismo nivel que las variables de instancia. • Se debe llamar a los métodos en el contexto de

una instancia concreta de esa clase. Esto se conoce a menudo como llamar a un método sobre un objeto.

Declaración de método (2)

• Los métodos se pueden referir directamente a variables de instancia sin utilizar el operador punto como si fueran simplemente variables locales declaradas en un ámbito externo.

• En la declaración de los métodos se define que devuelven un valor de un tipo concreto y que tienen un conjunto de parámetros de entrada.

• La forma general de una declaración de método es:

tipo nombre_de_método (lista-formal-de-parámetros) { cuerpo-del-método;}

Declaración de método (3)

• Ejemplo:

class Point {

int x, y;

void init(int a, int b) {

x = a;

y= b;

}

}

Llamada a método

Se llama a los métodos dentro de una instancia de una clase utilizando el operador punto (.). Su forma general es:

referencía_a_objeto.nombre_de_método(lista-de-parámetros);

• referencia_a_objeto: cualquier variable que se refiere a un objeto,• nombre_de_método: nombre de un método de la clase con la que

se declaró referencia_a_objeto • lista-de-parámetros: lista de valores o expresiones separados por

comas que coinciden exactamente en número y tipo con cualquiera de los métodos declarados como nombre_de_método en la clase.

Para llamar al método init sobre cualquier objeto Point para establecer x e y:

Point p = new Point();

p.init (10, 20);

this (1)

• Se utiliza dentro de cualquier método para referirse al objeto actual. El valor this se refiere al objeto sobre el que ha sido llamado el método actual.

• Se puede utilizar this siempre que se requiera una referencia a un objeto del tipo de la clase actual.

void init (int x, int y) {

this.x = x;

this.y = y;

}

this (2)class Point { int x, y; void init(int x, int y) { this.x = x; this.y = y; }}class TwoPointslnit { public static void main(String args[]) { Point pl = new Point(); Point p2 = new Point() ; pl.init(10, 20) ; p2.init(42, 99) ; System.out.println("x = " + pl.x + " y = " + pl.y); System.out.println("x = " + p2.x + " y = " + p2.y); }}

Constructores (1)

• Es un método que inicializa un objeto inmediatamente después de su creación.

• Tiene exactamente el mismo nombre de la clase en la que residen; no se puede tener ningún otro método que comparta su nombre con su clase.

• Una vez definido, se llama automáticamente al constructor después de crear el objeto, antes de que termine el operador new.

• No devuelven ningún tipo, ni siquiera void. Esto se debe a que el tipo implícito que devuelve un constructor de clase es el propio tipo de la clase.

• Es tarea del constructor inicializar todo el estado interno de un objeto para que el código que crea una instancia con el operador new tenga un objeto íntegro y utilizable inmediatamente.

Constructores (2)

class Point { int x, y; Point(int x, int y) { this.x = x; this.y = y; , } } class pointCreate { public static void main(String args[]) { Point p = new Point(10, 20) ; System.out.println("x = " + p.x + " y=" + p.y); } }

Sobrecarga de método (1)

• Es posible y a menudo deseable crear más de un método con el mismo nombre, pero con listas de parámetros distintas. A esto se le llama sobrecarga de método.

• La sobrecarga de método se utiliza para proporcionar a Java un comportamiento polimórfico.

• De manera simplificada, se sobrecarga un método siempre que se crea un método en una clase que ya tiene un método con el mismo nombre.

Sobrecarga de método (2)class Point { int x, y;

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

Point () { x= -1; y= -1; }}class PointCreateAlt { public static void main(String args[]) { Point p = new Point(); System.out.println("x = " + p.x + " y=" + p.y); }}

this en los constructores (1)

• Un refinamiento adicional es que un constructor llame a otro para construir la instancia correctamente.

• A menudo es una buena idea crear constructores relacionados para que las clases puedan evolucionar con más suavidad a lo largo del ciclo de desarrollo. Por ejemplo:class Point { int x, y; Point(int x, int y) { this.x = x; this.y = y; } Point() { this(-1, -1); }}

• El segundo constructor llama ahora al primero para terminar de inicializar la instancla.

this en los constructores (2)class Point {

int x, y; hc

point(int x, int y) {

this.x = x;

this.y = y;

}

double distance(int x, int y) {

int dx = this.x -x;

int dy = this.y -y;

return Math.sqrt(dx*dx + dy*dy);

}

double distance(Point p) {

return distance(p.x, p.y);

}

}

class pointDist {

public static void main(String args[]) {

Point pl = new Point( 0, 0) ;

Point p2 = new Point(30, 40) ;

System.out.println("pl = " + p1.x + ", " + p1.y);

System.out.println("p2 = " + p2.x + ", " + p2.y);

System.out.println("pl.distance(p2) = " + p1.distance(p2));

System.out.println("pl.distance(60, 80) = " + pl.distance(60, 80)) ;

}

}

Herencia• La herencia es un concepto que

relaciona clases una encima de otra de una manera jerárquica.

• Esto permite que los descendientes de una clase hereden todas las variables y métodos de sus ascendientes, además de crear los suyos propios.

• A estos descendientes se les llama subclases. Al padre inmediato de una clase se le llama su superclase.

• Una subclase es una versión especializada de una clase que hereda todos sus métodos y variables de instancia.

class Point3D extends Point {

int z;

Point3D(int x,int y,int z) {

this.x = x;

this.y = y;

this.z = z;

}

Point3D() {

this(-l, -1, -1);

}

}

super

• De manera similar a la utilización de this para referimos al primer constructor en el ejemplo Point, hay otra variable especial llamada super, que se refiere directamente a los constructores de la superclase.

• La referencia super también se podría utilizar para seleccionar directamente métodos con nombre además de constructores.

• Se puede pensar que super es como una versión de this que se refiere a la superclase.

• Por lo tanto, una sentencia como super.translate(x,y) significa una llamada al método translate de la superclase de la instancia this.

Final (1)• Todos los métodos y las variables de instancia se pueden

sobrescribir por defecto.• Si se desea declarar que ya no se quiere permitir que las subclases

sobrescriban las variables o métodos, éstos se pueden declarar como final.

• El modificador de tipo final implica que todas las referencias futuras a este elemento se basarán en esta definición.

• Esto se utiliza a menudo para crear el equivalente de una constante de C++, como en:

final int NUEVO_ARCHIVO = 1;final int ABRIR_ARCHIVO = 2;final int GUARDAR_ARCHIVO = 3;final int GUARDAR_ARCHIVO_COMO = 4;final int ABAND_ARCHIVO = 5;

Final (2)

• Es un convenio de codificación habitual el elegir identificadores en mayúsculas para variables final. Esta es también la única manera de crear el equivalente de un enum de C++.

• Las variables final no ocupan espacio en cada instancia. En ese aspecto, las variables final son iguales que las variables static.

• Se puede utilizar final como modificador en declaraciones de método cuando se desea no permitir que las subclases sobrescriban un método en concreto.

finalize• Java incluye un concepto llamado finalización que no se debe confundir con

el modificador de tipo final. • Dado que el intérprete de Java es un sistema de recogida de basura, por lo

general no hay que preocuparse por liberar la memoria asignada explícitamente. Esto es para lo que sirve delete de C++ o free en ANSI C.

• Sin embargo, hay circunstancias en las que se podría desear ejecutar algún código especial cuando el sistema de recogida de basura reclama un objeto.

• La finalización es muy simple. Se añade un método a cualquier clase con el nombre finalize y el intérprete de Java llama al método cuando vaya a reclamar el espacio de ese objeto. El método finalize debe realizar explícitamente cualquier acción que se requiera para liberar recursos externos.

• El sistema de recogida de basura se ejecuta periódicamente, buscando objetos que ya no estén referenciados por ningún estado en ejecución o indirectamente a través de otros objetos referenciados.

• Justo antes de liberar un objeto, Java llama al método finalize de ese objeto.