Clases y objetos. La unidad fundamental del lenguaje Java es la clase, que proporciona la estructura...

Clases y objetos

Clases y objetos La unidad fundamental del lenguaje Java

es la clase, que proporciona la estructura de los objetos y mecanismos para fabricarlos, a partir de su definición

Las clases definen métodos: colecciones de código ejecutable que es el foco de la computación y que manejan los datos almacenados en los objetos.

Los métodos proporcionan el comportamiento de los objetos de una clase.

Clases y objetos La programación orientada a objetos separa

estrictamente la noción de qué se va a hacer de cómo se va a hacer

El “qué” está descripto por un conjunto de métodos y su semántica asociada

Esta combinación se describe generalmente como un contrato entre el diseñador de la clase y el programador que la utiliza, porque dice lo que ocurre cuando se invocan ciertos métodos sobre un objeto

Este contrato define un tipo, de forma que todos los objetos que sean instancias de ese tipo respetan el contrato

Clases y objetos

El contrato del método, que incluye su signatura y su semántica (aunque sólo se describa en la documentación), define lo que significa

El “cómo” de un objeto está definido por su clase, que define la implementación de los métodos que tiene el objeto.

Clases y objetos

Cada objeto es una instancia de una clase.

Cuando se invoca a un método sobre un objeto, se examina la clase para obtener el código a ejecutar.

Un objeto puede utilizar a otros objetos para realizar su trabajo

Una clase simple Para declarar una clase se usa la

palabra class.

/* archivo Point3D.java */ public class Point3D { //----------------- atributos --------------------- private int x; private int y; private int z; //… }

Una clase simple Una declaración de clase crea un

nombre de tipo, por lo que las referencias a objetos de ese tipo pueden declararse simplemente como:

// declara referencia a puntos 3D Point3D pt1, pt2, pt3;

Esta declaración indica que pt1, pt2 y pt3 son variables que pueden almacenar una referencia a un objeto de tipo Point3D

Una clase simple

La declaración no crea un objeto, sino que declara sólo una referencia a la que le está permitido referirse a un objeto Point3D, durante su existencia la misma puede referirse a distintos objetos Point3D.

Esos objetos deben crearse explícitamente

Miembros de una clase Por ahora, una clase puede tener 2

clases de miembros: Los campos son variables de datos

asociadas con una clase y sus objetos. Almacenan el estado de una clase u objeto.

Los métodos contienen el código ejecutable de una clase y definen el comportamiento de los objetos

Modificadores de clase Una declaración de clase puede estar

precedida de modificadores de clase que le otorgan ciertas propiedades, por ahora veremos:

public: la clase es accesible públicamente, cualquier clase puede declarar referencias a objetos de ella o acceder a sus miembros públicos. Sin este modificador la clase es sólo accesible dentro de su propio paquete.

Modificadores de clase

La mayoría de las herramientas de desarrollo Java requieren que se declare una clase public en un archivo con el mismo nombre que la clase y, por tanto, sólo puede haber una clase public declarada por archivo

Campos Las variables de una clase se llaman

campos. Ej.: Las variables x, y y z de la clase Point3D. Cada objeto de esta clase tiene sus instancias específicas de los 3 campos

La declaración de un campo consiste en un nombre de tipo seguido del nombre del campo y opcionalmente de una cláusula de inicialización, para dar al campo un valor inicial.

Al dar a cada objeto diferente una instancia diferente de sus campos, cada uno tiene su propio estado único (variables de instancia). Al cambiar el campo x de un objeto Point3D no se afecta al campo x de cualquier otro Point3D.

Campos Las declaraciones de los campos

pueden precederse también con modificadores que controlan ciertas propiedades de los mismos. Por ahora veremos los siguientes y se recomienda al aplicar varios seguir este orden:

Modificadores de acceso static final

Inicialización de los campos

Cuando se declara un campo, puede inicializarse asignando un valor del tipo correspondiente

El inicializador (o expresión de inicialización) puede ser una constante, otro campo, una invocación a un método, o una expresión que involucre las 3 cosas. El único requisito es que sea del tipo correcto.

Aunque los inicializadores proporcionan una gran flexibilidad en la forma de inicializar los campos, sólo son adecuados en esquemas simples de inicialización, en esquemas más complejos son necesarias herramientas adicionales

Inicialización de los campos

Ejemplo:

double cero=0.0;//constante

double suma= 4.5 +3.7; //expresión constante

double copiaCero= cero; //campo

double raizDos= Math.sqrt(2);// invocación a un método

double algunVal= sum + 2*Math.sqrt(raizDos); //mezcla

Inicialización de los campos Si un campo no se inicializa, se le asigna un

valor inicial por defecto, en función del tipo:Tipo Valor inicial

boolean False

char ‘\u0000’

enteros 0

float +0.0 f

double +0.0

ref. a objetos null

Campos estáticos Algunas veces se desea tener sólo una

instancia de un campo, compartida por todos los objetos de una clase. Esos campos ( campos estáticos o variables de clase) se declaran como static.

Cuando se declaran sólo existe una copia del mismo, independientemente del número de instancias de la clase que se creen.

Ejemplo: static int sigID=0;

Campos estáticos El campo se inicializa con un valor 0 cuando

se inicializa la clase, después de cargarla. Cada objeto que se crea tiene asignado como identificador el valor en curso sigID

Puede ser referido directamente dentro de la clase pero cuando se accede externamente a él, hay que usar el nombre de la clase. Ej:

System.out.println(Point3D.sigID); Es el tipo de la referencia, el que determina

la clase en que hay que buscar la variable estática

Campos final

Es aquél cuyo valor no se puede cambiar después de ser inicializado. En general, se usan para definir propiedades inmutables de una clase u objeto, es decir aquéllas que no cambian durante el tiempo de vida de la clase u objeto

Campos final Si el campo no tiene un inicializador

se llama final en blanco. Es útil cuando no se puede inicializar el campo en forma simple. Se deben inicializar una vez que la clase se ha inicializado (en el caso de campos final estáticos), o una vez que el objeto de la clase se ha construido completamente (caso no estáticos)

Campos final El compilador se asegura de esto y

rechaza compilar una clase si determina que un campo final no queda inicializado.

Si una propiedad cambia poco frecuentemente, en vez de ser verdaderamente inmutable no es apropiado un campo de este tipo.

Sino se conoce el valor de un campo cuando se crea el objeto tampoco (incluso aunque sea lógicamente inmutable)

Campos final Si la inicialización del campo es

costosa y el valor no se necesita frecuentemente puede ser más práctico retrasar la inicialización del campo hasta que se necesite su valor (inicialización perezosa), que no se puede aplicar a un campo de este tipo. Puede reducir la sobrecarga en situaciones en las que no es necesario crear siempre el objeto

Control de acceso Si cualquier miembro de una clase fuese

accesible para cualquier clase u objeto la comprensión, depuración y mantenimiento de los programas sería una tarea casi imposible, sería imposible fiarse de los contratos presentados por las clases: cualquier segmento de código podría acceder a un campo y cambiarlo de forma que se violara un contrato.

Control de acceso Uno de los puntos más fuertes de la

programación orientada a objetos es que proporciona soporte para el encapsulamiento y la ocultación de datos. Se necesita una forma de controlar quien accede a qué miembros de una clase, incluso quién accede a la propia clase. Este control se especifica usando modificadores de acceso en las declaraciones de clases y miembros.

Control de acceso

Todos los miembros de una clase son siempre accesibles al código de la propia clase. Para controlar el acceso desde otras clases, los miembros de una clase tienen, por ahora, los siguientes modificadores de acceso:

private: los miembros son sólo accesibles en la propia clase

Control de acceso package: los miembros declarados sin

modificador de acceso son accesibles en todas las clases del mismo paquete, así como en la propia clase

public: los miembros son accesibles en cualquier parte donde la clase sea accesible

El modificador private sólo se aplican a miembros, no a las propias clases. Para que un miembro sea accesible desde una sección de código de alguna clase, primero dicha clase debe ser accesible a ese código

Control de acceso

Es importante tener en cuenta que el control de acceso se realiza al nivel de clase, no al nivel de objeto. Esto significa que los miembros de una clase son siempre accesibles desde todo el código escrito en esa clase, independientemente de qué instancia del código está siendo aplicada.

Control de acceso Los miembros públicos se deben ver como

contractuales ya que, código que no controlamos se puede fiar de ellos. Cambiarlos puede ser imposible después que exista dicho código que se base en su funcionalidad pública.

El acceso privado y de paquete son parte de nuestra implementación, oculta del exterior

Las clases de un mismo paquete deberían estar relacionadas

Creación de objetos La construcción mediante new es con mucho

la forma más común de crear objetos, se especifica el tipo de objeto que se desea crear y los parámetros que se utilizarán para su construcción.

El sistema en tiempo de ejecución reserva espacio suficiente para almacenar los campos del objeto y lo inicializa como se verá

Cuando la inicialización se completa el sistema en tiempo de ejecución devuelve una referencia al nuevo objeto

Creación de objetos

Si el sistema no puede encontrar espacio suficiente para crear el objeto, puede usar el recolector de basura para intentar obtener espacio. Si a pesar de todo no se consigue se muestra un mensaje OutOfMemoryError

Una vez creado un nuevo objeto se inicializan sus variables

Creación de objetos Los objetos creados nunca se borran

explícitamente. La máquina virtual gestiona la memoria por nosotros, usando recogida de basura, ella puede reclamar espacio de objetos que posiblemente no se van a usar más sin nuestra intervención.

Si un objeto no se necesita más, dejaremos de referirnos a él. En el caso de variables locales dentro de métodos esto puede ser tan simple como retornar del mismo (cuando el método no se ejecuta, posiblemente ninguna de sus variables se utilizará). En el caso de campos, se los puede poner a null.

Construcción e inicialización

Un objeto de nueva creación recibe un estado inicial. Los campos pueden inicializarse dándoles un valor cuando se declaran o pueden aceptar su valor por defecto, lo que algunas veces es suficiente para asegurar un valor inicial correcto.

Con frecuencia es necesario algo más que una inicialización simple para crear el estado inicial. El código de creación de un objeto puede necesitar suministrar datos iniciales o realizar operaciones que no pueden expresarse mediante una simple asignación

Constructores Para realizar cometidos más complejos

que la simple inicialización, las clases pueden tener constructores: bloques de sentencias que pueden usarse para inicializar un objeto antes de que se devuelva una referencia a dicho objeto mediante new.

Los constructores tienen el mismo nombre de la clase que inicializan. Como los métodos pueden admitir 0 o más parámetros. Si los hay se proporcionan entre los () que siguen al nombre del tipo cuando se crea el objeto con new.

Constructores

Los constructores se invocan después de que las variables de instancia del objeto de nueva creación tengan asignados sus valores iniciales por defecto y después de que sus inicializadores explícitos se hayan ejecutado

Constructores

public Point3D(int x1, int y1, int z1) { // valores iniciales (x1,y1,z1) x = x1; y = y1; z = z1; }

Constructores

La declaración de un constructor consiste en el nombre de la clase seguido por una lista de parámetros (puede estar vacía) entre () y un cuerpo de sentencias encerradas entre {}.

Pueden tener cualquier modificador de acceso como miembros de una clase, pero no son miembros de una clase

Constructores

Cuando el constructor vuelve de las invocaciones, todos los campos de datos del nuevo objeto tienen asignado algún valor inicial razonable. int a1 = 10, b1 = -5, c1 = 4;

// para constructor// declara referencia a puntos 3D

Point3D pt2;// instancia

pt2 = new Point3D(a1, b1, c1);

Constructores No son métodos y por tanto no tienen tipo

de retorno Se puede proporcionar más de un

constructor que invoque a otro de la misma clase usando la invocación (explícita a un constructor) this() como su primera sentencia ejecutable (obligatorio)

Si el constructor que se desea invocar tiene parámetros, se pueden pasar a la invocación al constructor. El tipo y número de ellos están determinados por el constructor que se invoca.

Constructores

public Point3D() { // valores por defecto this(0,0,0); } //instancia Point3D pt1 = new Point3D();

Constructores La lista de parámetros determina a qué

versión del constructor se invoca como parte de la expresión new

Cualquier expresión que se use como parámetros en la invocación explícita a un constructor no debe referirse a campos o métodos del objeto actual. A todos los efectos, no hay objeto actual en este estado de construcción

Constructores

Razones típicas para proporcionar constructores especializados:

Algunas clases no tienen un estado inicial razonable sin parámetros

Proporcionar un estado inicial resulta conveniente y razonable cuando se construyen ciertas clases de objetos

Constructores La construcción de un objeto puede

ser una operación potencialmente costosa, por lo que es conveniente que los objetos tengan un estado inicial correcto cuando se crean. Ej.: cada objeto de una clase tiene una tabla disponer un constructor para especificar el tamaño inicial de ella es más eficiente que crearla con tamaño por defecto

Constructores

Un constructor que no es público impone restricciones sobre quién puede crear objetos utilizándolos. Ej: evitar que programadores usen nuestro paquete para crear instancias de una clase haciendo sus constructores sólo accesibles desde el interior del paquete

Constructores Aquéllos sin parámetros son tan habituales

que se los llama no-arg (de no argumentos (parámetros))

Sino proporcionamos constructores de algún tipo para una clase, el lenguaje proporciona un constructor de este tipo que no hace nada (constructor por defecto), sólo se proporciona automáticamente sino existen otros constructores, puesto que hay clases para las que un construrctor no-arg sería incorrecto.

Constructores

Si se desea tener simultáneamente un constructor no-arg y uno o más constructores con parámetros, hay que proporcionar explícitamente un constructor no-arg.

El constructor por defecto tiene la misma accesibilidad que la clase en la que se define

Constructores Existe otro constructor que se denomina

constructor de copia que toma un parámetro del tipo del objeto actual y construye un nuevo objeto como una copia del objeto que se pasa.

Generalmente esto es una forma de asignar los mismos valores a todos los campos pero algunas veces la semántica de una clase dicta acciones más sofisticadas

Constructorespublic Point3D(Point3D otro){

this.x=otro.x;

this.y=otro.y;

this.z=otro.z;

}

public Point3D(int low, int high) {

//random x,y,z generado en el rango low..high

x = (int) (low + Math.random() * (high - low));

y = (int) (low + Math.random() * (high - low));

z = (int) (low + Math.random() * (high - low));

}

Bloques de inicialización

Otra forma de realizar inicializaciones más complejas de campos es utilizar estos bloques

Son bloques de sentencias que aparecen dentro de la declaración de la clase y fuera de la declaración de cualquier miembro o constructor, y que inicializa los campos del objeto

Bloques de inicialización

Se ejecuta como si estuviese situado al principio de cada constructor de la clase

Si hay múltiples bloques se ejecutan en el orden en que aparecen en la clase

Bloques de inicializaciónpublic Point3D{private int x, y, z;private int numId;private static int sigID=0;{numId=sigID++;}public Point3D(int x1, int y1, int z1){x=x1;y=y1;z=z1;}}

Bloques de inicialización En la práctica, los bloques de

inicialización tienden a ser utilizados en inicializaciones no triviales, cuando no se necesitan parámetros de construcción

Se usan para la inicialización pero en la práctica pueden servir para cualquier cosa, ya que el compilador no comprueba lo que hacen

Inicialización estática Los campos estáticos de una clase

pueden tener inicializadores pero además se pueden realizar una inicialización estática más compleja usando un bloque de inicialización estática.

Son muy parecidos a los no estáticos excepto porque se declaran static, sólo pueden referirse a miembros estáticos de la clase.

Inicialización estática Ej.: La creación de un array estático y la

inicialización de sus elementos se puede hacer algunas veces con sentencias ejecutables.

El orden de inicialización dentro de una clase es desde el primero al último. Cada inicializador de un campo o bloque de inicialización se ejecuta antes que el siguiente, desde el inicio del código hasta el final.

Se ejecutan cuando se carga la clase

Inicialización estáticaclass Primos{

static int[] primosConocidos=new int[4];

//se crea antes de ejecutar el bloque

static{

primosConocidos[0]=2;

for(int i=1; i<primosConocidos.length;i++)

primosConocidos[i]=sigPrimo();

}//el campo static ha sido inicializado

//declaración de sigPrimo()

}

Métodos Contienen el código que entiende y

maneja el estado de un objeto. Algunas clases tienen campos públicos

para que los programadores los manejen directamente, esto no es muy buena idea en la mayor parte de los casos. Muchos objetos tienen tareas que no pueden representarse como la lectura o modificación de un simple valor, sino que requieren cómputo

Métodos La declaración de un método consta de

2 partes: la cabecera y el cuerpo La cabecera consta de una serie de

modificadores, el tipo de retorno del método y la signatura

La signatura consta del nombre del método y la lista de parámetros (que puede estar vacía) entre ().

Todos los métodos deben tener un tipo de retorno y una signatura, los modificadores son opcionales

Métodos El cuerpo consta de las sentencias

encerradas entre llaves Por ahora, los modificadores de un

método pueden ser: Modificadores de acceso static Cuando se usan varios se

recomienda seguir este orden

Métodos estáticos

Se invoca en nombre de una clase completa, no sobre un objeto específico instanciado a partir de esa clase.

Se conocen como métodos de clase Podrían realizar una tarea general para

todos los objetos de la clase, ejemplo devolver el siguiente número de serie

Métodos estáticos

Pueden acceder sólo a campos estáticos o a otros métodos estáticos de la clase. Los miembros no estáticos deben accederse mediante una referencia a un objeto y no hay ninguna referencia a un objeto disponible dentro de un método estático. No hay referencia this

Invocaciones de métodos Los métodos se invocan como

operaciones sobre objetos, mediante referencias usando el operador punto (.)

referencia.método(parámetros) Cada método se declara con un número

específico de parámetros, cada uno de ellos de un tipo específico: un tipo primitivo o un tipo de referencia.

Invocaciones de métodos No pueden declararse métodos con un

número variable de parámetros, aunque es posible declarar un método con un array de objetos como parámetro.

Cuando se invoca a un método, el que lo invoca debe proporcionar un parámetro del tipo apropiado para cada uno de los parámetros declarados en el método

Los métodos también tienen un tipo de retorno, primitivo o de referencia. Si un método no devuelve ningún valor se pone void

Invocaciones de métodos

En lugar de acceder y preguntar por todos los campos del objeto (estado), una clase puede definir un método que devuelva una representación en cadena de texto del estado del mismo


// --------------------- metodos - utilidad ----------------------- public String toString() { return ("(x: " + x + ", y: " + y + ", z: " + z + ")"); }


El método construye una cadena y la resultante se devuelve al que invoca mediante la sentencia return

El método toString de un objeto es especial. Se invoca para obtener un String cuando se utiliza un objeto en una concatenación de cadenas de texto con el operador +.

Invocaciones de métodos System.out.println("Punto 2 ahora es: " + pt2);

Los métodos toString se invocan implícitamente

Todos los objetos tienen este método, tanto si su clase define uno explícitamente o no, es porque todas las clases extienden de Object que define este método

Ejecución de un método y retorno Cuando se invoca a un método, el flujo

de control pasa del método que invoca al método invocado y, se ejecutan las sentencias del mismo en secuencia, de acuerdo con la semántica de dichas sentencias. Un método completa su ejecución y retorna al que lo llama cuando sucede una de estas 3 cosas: se ejecuta una sentencia return, se alcanza el final del método o se lanza una excepción no capturada

Ejecución de un método y retorno Si un método devuelve algún resultado,

este debe ser único, o un valor primitivo o una referencia a un objeto.

Si necesita devolver más de un resultado pueden conseguir este efecto de varias formas: devolver referencias a objetos que almacenan los resultados como campos, tomar uno o más parámetros que se refieran a objetos en los que almacenar los resultados o, devolver un array que contenga los resultados.

Ejecución de un método y retorno

public Point3D translate(int tx, int ty, int tz) { Point3D q = new Point3D(x + tx, y + ty, z + tz); return (q); }

// mueve pt1 de nuevo y chequea si es igual a pt2Point3D pt4 = pt1.translate(shift2X,

shift2Y, shift2Z);

Ejecución de un método y retorno

En métodos que devuelvan un valor cualquier vía de ejecución del método debe, o bien retornar un valor que sea asignable a una variable del tipo de retorno declarado o bien lanzar una excepción.

Valores de parámetros Todos los parámetros de métodos se

pasan “por valor”. Los valores de las variables parámetro en un método son copias de los valores que el que lo invoca especificó como parámetros.

Si se pasa un double a un método, su parámetro es una copia del valor que se pasa como parámetro y, un método puede cambiar el valor de su parámetro sin afectar los valores en el código que lo invocó

Valores de parámetrospublic class PasaPorValor {public static void main(String[] args) { double uno=1.0; System.out.println("antes: uno= "+uno); calculaMitad(uno); System.out.println("después: uno= "+uno); }public static void calculaMitad(double arg){arg/=2.0;//divide arg por 2System.out.println("mitad: arg= "+arg);}}

Valores de parámetros

Salida por pantalla:

antes: uno= 1.0

mitad: arg= 0.5

después: uno= 1.0

Valores de parámetros Cuando el parámetro es una referencia a un

objeto, la referencia al objeto es lo que se pasa por valor (no el objeto mismo). Por tanto se puede cambiar a qué objeto se refiere un parámetro dentro de un método sin afectar la referencia que se pasó. Pero si se cambian campos del objeto o se invocan métodos que cambian el estado del objeto, el objeto quedará modificado en cualquier parte del programa que se refiera a él (ambos apuntan al mismo área de memoria)


Si origen y destino son las mismas cuentas pueden anularse sus saldos

Valores de parámetros Los parámetros de los métodos pueden

declararse final, lo que significa que el valor del parámetro no cambiará mientras el método se ejecuta, el compilador chequea este hecho

Esta declaración puede ayudar además al compilador o a la máquina virtual a optimizar algunas expresiones que utilicen el parámetro, dado que se sabe que no se va a modificar


Un modificador final sobre un parámetro es un detalle de implementación que afecta sólo al código del método, no al código de quien invoca al método. Por tanto se puede cambiar la condición de final de un método sin afectar a cualquier posible código que invoque al método

Uso de métodos para control de acceso

Para forzar que el acceso a un campo sea de sólo lectura durante el tiempo de vida del objeto se lo puede ocultar haciéndolo private y proporcionar un nuevo método de forma que el código externo a la clase pueda leer su valor utilizando ese método (métodos accesores)

Uso de métodos para control de acceso Incluso aunque una aplicación no

requiera que los campos sean de sólo lectura, hacer los campos privados y añadir métodos para leer y escribir dichos datos nos permite añadir acciones que se pueden necesitar en el futuro.

Si los programadores pueden acceder a los campos de una clase directamente, no tenemos control sobre los valores que usarán o sobre lo que sucede cuando los valores se modifican


Al hacer un campo parte del contrato de una clase se bloquea en la implementación de esa clase. No se puede cambiar la implementación sin forzar la recompilación de todos los clientes


public void setX(int x1) { x = x1; } public void setY(int y1) { y = y1; } public void setZ(int z1) { z = z1;


public int getX() { return x; } public int getY() { return y; } public int getZ() { return z; }


Hacer que un campo sea final es a veces una alternativa que evita modificaciones no deseadas de dicho campo, pero no se deben confundir inmutabilidad con accesibilidad. Si un campo es inmutable se debe declarar final independientemente de su accesibilidad. Por el contrario sino se desea que un campo forme parte del contrato de una clase se debe ocultar tras un método, independientemente de si el campo es de sólo lectura o modificable


Si se usan todos los campos private el control de acceso se realiza por clase y no por objeto

public void cambiax(Point3D victima){

victima.x=this.x;

}


Si el control de acceso se realizara por objeto el método cuando se invocara sobre un objeto no podría acceder al campo privado x de víctima para modificarlo pero, como el control de acceso se realiza por clase, el código de un método de una clase tiene acceso a todos los campos de esa clase.


Algunos lenguajes orientados a objetos son partidarios del control de acceso por objeto, Java no es uno de ellos

this Se puede usar la invocación explícita a

un constructor para invocar a otro de los constructores de nuestra clase al principio de un constructor.

Se puede usar también la referencia especial a un objeto this dentro de un método no estático, que se refiere al objeto actual sobre el que se invocó al método. No existe la referencia this en un método estático porque no se está operando sobre ningún objeto específico

this

La referencia this se usa comúnmente como una forma de pasar una referencia al objeto actual como parámetro para otros métodos.

Suponga que un método requiera añadir el objeto actual a una lista de objetos que esperan recibir algún servicio:

this

servicio. captura(this); Se puede añadir un this explícito al

principio de cualquier acceso a un campo o invocación del método del objeto actual.

this

public double distanceToPoint(Point3D q) { return ( Math.sqrt( (this.x - q.x) * (this.x - q.x) + (this.y - q.y) * (this.y - q.y) + (this.z - q.z) * (this.z - q.z))); }

this

Convencionalmente usaremos this sólo cuando sea necesario: cuando el nombre del campo al que se necesita acceder esté oculto por una variable local o una declaración de parámetro.

this public void shiftX(int x) {this.x = this.x + x;} Se usa this para especificar que el nombre

es del campo perteneciente a “este (this)” objeto

La ocultación deliberada de identificadores realizada de esta forma se considera una práctica de programación aceptable sólo en este uso idiomático en constructores y métodos de establecimiento

Sobrecarga de métodos Todos los métodos tienen una signatura,

que consiste en su nombre junto con el número y tipo de parámetros.

Dos métodos pueden tener el mismo nombre si tienen diferente número o tipo de parámetros y por tanto, diferente signatura (sobrecarga) porque el nombre simple del método tiene un significado sobrecargado (tiene más de un significado)

Sobrecarga de métodos

Cuando se invoca un método el compilador compara el número y tipo de parámetros para encontrar el método que mejor se ajusta entre las signaturas posibles.

Si la invocación no se ajusta a ninguna de las signaturas de los métodos sobrecargados, el código no compila


La signatura no incluye el tipo de retorno y no se pueden sobrecargar métodos basándose en ello.

Los constructores se pueden sobrecargar de la misma forma que los métodos


public boolean equals(Point3D q) // es este punto igual a q? { return (this.x == q.x && this.y == q.y && this.z == q.z); } public boolean equals( int x1, int y1, int z1) // es este punto igual al (x1,y1,z1)? { return (this.x == x1 && this.y == y1 && this.z == z1); }

Sobrecarga de métodos System.out.println("Es pt1 igual a pt2? > " + pt1.equals(pt2));

System.out.println(

"Es este nuevo punto transladado pt4 igual a pt2? > "

+ pt4.equals(pt2.getX(), pt2.getY(), pt2.getZ()));

El método main()

Los detalles para invocar a una aplicación varían de un sistema a otro, pero independientemente de los detalles, siempre debemos proporcionar el nombre de una clase que conduzca la aplicación. Cuando ejecutamos un programa el sistema localiza y ejecuta el método main de esa clase.

El método main()

El método debe ser public, static y void (no devuelve nada) y debe aceptar un único parámetro de tipo String[]

El método main() public class Eco {

public static void main(String[] args) {

for (int i=0; i<args.length; i++)

System.out.print(args [i]+ " ");

System.out.println();

}

}

El método main()

Sale por pantalla: estamos aquí Una aplicación puede tener cualquier

número de métodos main ya que cada clase de la aplicación puede tener uno. Sólo se usará un main cada vez que se ejecuta un programa. El main que se utiliza en concreto se especifica cuando se ejecuta el programa

Clases y objetos. La unidad fundamental del lenguaje Java es la clase, que proporciona la estructura...

Documents

Transcript of Clases y objetos. La unidad fundamental del lenguaje Java es la clase, que proporciona la estructura...