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
Constructores
public 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ón
public 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ática
class 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
Invocaciones de métodos
// --------------------metodos - utilidad ---------------------public String toString() {
return ("(x: " + x + ", y: " + y + ", z: " + z +
")");
}
Invocaciones de métodos


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 pt2
Point3D 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ámetros
public 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 2
System.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)
Valores de parámetros
Valores de parámetros
Valores de parámetros
Valores de parámetros

Si origen y destino son las mismas
cuentas pueden anularse sus saldos
Valores de parámetros
Valores de parámetros
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
Valores de parámetros

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
Uso de métodos para control
de acceso

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
Uso de métodos para control
de acceso
public void setX(int x1) {
x = x1;
}
public void setY(int y1) {
y = y1;
}
public void setZ(int z1) {
z = z1;
Uso de métodos para control
de acceso
public int getX() {
return x;
}
public int getY() {
return y;
}
public int getZ() {
return z;
}
Uso de métodos para control
de acceso

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
Uso de métodos para control
de acceso
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;
}

Uso de métodos para control
de acceso

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.
Uso de métodos para control
de acceso

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
Sobrecarga de métodos


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
Sobrecarga de 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
Descargar

Clases y objetos