Universidad Tecnológica de El Salvador

Programación III MSc. René Alberto Castro Velásquez

UNIDAD II – CREACIÓN DE PAQUETES PARA TRABAJAR CON CLASES Y

OBJETOS.

2.2. MIEMBROS DE UNA CLASE.

INTRODUCCIÓN.
Una clase en Java tiene tres
elementos claramente
definidos:
1. Propiedades: es el
nombre con el cual se
conoce a las variables
de instancia, y permiten
almacenar valores.
2. Métodos: es el nombre
con el cual se conoce a
las operaciones que puede realizar un objeto.
3. Constructores: es un tipo especial de método que es usado para inicializar un objeto, y es
invocado al momento de crear un objeto.
A estos tres elementos se les conoce como miembros de una clase.

INSTANCIAR UN OBJETO.
En Java la palabra new es usada para instanciar
un objeto. El operador new crea el objeto en
memoria y devuelve una referencia al objeto
recién creado. Este objeto permanecerá en
memoria mientras el programa mantenga una
referencia al objeto.
Las siguientes sentencias declaran una
referencia a un objeto (una referencia es una
variable que apunta hacia un objeto) y usa la
palabra reservada new para asignar esta
referencia al nuevo objeto emp, el cual es construido a partir de la clase Empleado.
Empleado emp;
emp = new Empleado();

También puede usar la sintaxis abreviada siguiente:

Empleado emp = new Empleado();

Para cualquiera de los dos códigos mostrados, la referencia emp está apuntando hacia el objeto
construido a partir de la clase Empleado que se encuentra en memoria.

Página 1 de 10
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

PROPIEDADES.
Una propiedad se declara de forma similar a
una variable, pero se hace dentro de la clase.
Por ejemplo, el código siguiente declara algunas
variables dentro de la clase Empleado.
class Empleado {
public String nombre;
public double salario;
}

Es común que el programador no le asigne un

valor a la propiedad que está declarando dentro
de la clase. En este caso, el operador new
reserva memoria para el objeto y luego “vacía”
la memoria de tal manera que ninguno de los campos del objeto contenga basura. En su lugar,
todos los campos tendrán un valor inicial. La tabla siguiente muestra el valor inicial que contendrá
un campo dependiendo de su tipo de datos.

Tipo de datos Valor inicial

byte 0

short 0

int 0

long 0

float 0.0

double 0.0

char null

boolean false

Referencia de null
cualquier tipo

Es importante enfatizar que dos entidades están siendo creadas en memoria: la referencia y el
objeto. En las sentencias anteriores, emp es declarada como una referencia a un objeto Empleado,
lo cual quiere decir que emp puede referirse a cualquier objeto creado a partir de la clase
Empleado. A continuación emp es asignada a un objeto new Empleado.

Página 2 de 10
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

ENTENDIENDO LAS REFERENCIAS.

Una referencia es (típicamente) un valor entero
de 32 bits que contiene la dirección en memoria
del objeto al cual se refiere. Se dice
“típicamente” porque el tamaño de una
referencia no es estrictamente definido en las
Especificaciones del Lenguaje Java. En el futuro,
las referencias probablemente serán enteros de
64 bits o mayores. De manera similar, pueden
ser menores de 32 bits cuando son usados con
sistemas operativos para pequeños dispositivos
electrónicos.
Debido a que las referencias son esencialmente enteros, se preguntará por qué necesitan ser
declaradas como un tipo particular de datos. Esto es porque los tipos de datos están estrictamente
forzados en Java. Una referencia debe ser de un tipo de datos de clase en particular.
Por ejemplo, las siguientes sentencias localizan en memoria a tres referencias hacia Empleado y
una referencia hacia String.
Empleado e1, e2, e3;
String cad;

Cada una de las tres referencias consume la misma cantidad de memoria y son esencialmente de
tipo de datos entero. Sin embargo, las referencias e1, e2 y e3 pueden referirse sólo a objetos
Empleado. La referencia cad puede referirse sólo a objetos String. Para ilustrar este punto, las
siguientes sentencias intentan romper esta regla y no son válidas:
cad = new Empleado(); // No compila
e1 = "Millonario"; // No compila

Podrá creer que al usar el operador cast se podría crear una salida a esta situación:
e1 = new Empleado(); // Válido
cad = e1; // No compila
cad = (Empleado) e1; // No compila
cad = (String) e1; // No compila

Sin embargo, el compilador sabe que los objetos String y los objetos Empleado no son compatibles
y generarán errores de compilación en las sentencias previas.
Las referencias e1 y e2 son del mismo tipo de datos y pueden ser asignadas entre sí. Por ejemplo:
e1 = new Empleado();
e2 = e1; // Válido

La referencia e1 es asignada a un objeto new Empleado y la referencia e2 es asignada a e1. Esto es

válido porque e1 y e2 son ambas referencias a Empleado y por tanto son del mismo tipo de datos.
Este objeto new Empleado ahora tiene dos referencias apuntando a él (observe que sólo hay un
objeto Empleado en memoria porque sólo usamos la palabra new una sola vez). El asignar e1 a e2
no crea un nuevo objeto.
Se podría haber declarado la referencia e y luego instanciar al objeto Empleado en una sola
sentencia.

Página 3 de 10
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

Empleado e1 = new Empleado();

Esta sentencia crea dos elementos separados en memoria: la referencia e1 y el objeto Empleado.
La referencia e1 no es un objeto. El objeto por sí mismo no tiene un nombre de variable y la única
forma de tener acceso y usarlo es utilizando una referencia al objeto.
e3 = new Empleado();
e2 = e3; // ¿qué sucede con el primer objeto?
e1 = e2; // ¿qué sucede con el primer objeto?

EL RECOLECTOR DE BASURA.
En otros programas se puede efectuar la liberación de memoria de forma
explícita, pero en Java no existe ninguna palabra reservada u operador
que pueda ser usado para eliminar un objeto de la memoria. Java fue
diseñado para evitar los problemas de administración de memoria que
aparecen en otros lenguajes. Una JVM tiene un hilo de bajo nivel
conocido como el recolector de basura que está ejecutándose
constantemente en el fondo buscando objetos en el programa Java que
ya no estén siendo usados y liberando esa memoria.
El concepto de la recolección automática de basura hace que los programadores se sientan
excitados y nerviosos. El recolector de basura es atractivo porque los programadores no tienen
que pasar horas tras horas preocupándose sobre cómo resolver problemas de administración de
memoria. Sin embargo, los programadores se sienten nerviosos porque pierden el control de ser
capaces de liberar la memoria en cualquier punto del programa porque la memoria será liberada
en un programa Java solamente cuando el recolector de basura concluya que la memoria ya no
está siendo usada.
Un objeto es marcado para ser recogido por el recolector de basura cuando ya no es accesible en
el programa. Para que esto suceda, las referencias que aún se encuentran dentro del alcance de la
aplicación Java ya no deben referirse al objeto, sino que se les asigna null, se les hace que apunten
hacia otro objeto o se hace que salgan de alcance.
En Java no se puede liberar memoria de forma explícita. Sin embargo, hay un método que se
puede invocar: System.gc(), el cual hace que el recolector de basura “invierta esfuerzos para
reciclar objetos que ya no se usan”, como lo establece la documentación del fabricante. El método
gc() es muy dependiente de la JVM, de modo que su comportamiento es difícil de predecir. Sin
embargo, es el único mecanismo para comunicarse con el recolector de basura.

Página 4 de 10
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

MÉTODOS.
Un método proporciona la operación que realiza un objeto y tiene la sintaxis siguiente:
visibilidad tipoDeDatosDeRetorno nombreDelMétodo(listaDeArgumentos) {
// Cuerpo del método
}

Donde:
visibilidad: define quién puede tener acceso al
método.
tipoDeDatosDeRetorno: define el tipo de datos que
tiene el valor que es devuelto por el método.
nombreDelMétodo: define el nombre con el cual se
identifica el método.
listaDeArgumentos: define un listado de parámetros
que son recibidos por el método. Este listado es
opcional, por lo que se puede crear e invocar métodos
sin parámetros.
Cuerpo del método: define el código que contiene el método y que es ejecutado cuando
es invocado.

¿Argumento o parámetro? Ambos términos se refieren a un dato que viaja, pero se le llama
“argumento” en el punto donde el dato es enviado, y “parámetro” en el punto donde el dato es
recibido.

ACCESO A PROPIEDADES Y MÉTODOS.

Cuando se instancia un objeto usando la palabra reservada new,
cierta cantidad de memoria es reservada para las propiedades y
métodos en la clase. Se requiere una referencia al objeto para
acceder a estas propiedades y métodos usando el operador punto.
Por ejemplo, la sentencia siguiente declara un objeto Empleado y
guarda un valor en la propiedad del objeto:
Empleado e = new Empleado();
e.nombre = "Gustavo Cerati";

La operación e.nombre es la forma de acceder a la propiedad nombre del objeto Empleado al cual
se refiere e. De manera similar, la siguiente sentencia utiliza el operador punto para invocar el
método enviarCheque() de este objeto Empleado en particular:
e.enviarCheque();

Página 5 de 10
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

EL OPERADOR PUNTO.
El operador punto (.), también conocido como separador o período, es utilizado
para separar una variable o método de una variable de referencia.
Solo se puede acceder a las variables o métodos estáticos utilizando el nombre de
la clase.
El código que está fuera de la clase del objeto debe usar una referencia o expresión de objeto,
seguido del operador de punto (.), seguido de un nombre de campo, como por ejemplo:
ReferenciaDeObjeto.nombreDelCampo;

Se usa la referencia de objeto para invocar el método de un objeto. Agregue el nombre del
método a la referencia del objeto, con un operador de punto intermedio (.), como por ejemplo:
ReferenciaDeObjeto.nombreDelMétodo(listaDeArgumentos);

La clase Empleado quedaría así:

public class Empleado {
public String nombre;
public String direccion;
public int numero;
public int ISSS;
public double salario;

public void enviarCheque() {

System.out.println("Enviar cheque a " + nombre + "\n" + direccion);
}
public double calcularPago() {
return salario / 52;
}
}

El programa de demostración quedaría así:

public class EmpleadoDemo {
public static void main(String [] args) {
Empleado e1, e2;
e1 = new Empleado();
e2 = new Empleado();

e1.nombre = "Gustavo Cerati";

e1.direccion = "Calle Principal # 123 Santa Tecla";
e1.numero = 101;
e1.ISSS = 111223333;
e1.salario = 24000.00;
System.out.println(e1.nombre + " " + e1.ISSS);
System.out.println(e1.calcularPago());
e1.enviarCheque();

e2.nombre = "Jairo Varela";

e2.direccion = "Calle Principal #321 San Miguel";
e2.numero = 202;
e2.ISSS = 333221111;
e2.salario = 30000.00;

Página 6 de 10
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

System.out.println(e2.nombre + " " + e2.ISSS);

System.out.println(e2.calcularPago());
e2.enviarCheque();
}
}

LA REFERENCIA THIS.
Cada objeto tiene una referencia a sí mismo, la cual está representada por
la palabra reservada this. La referencia this es usada en los métodos de una
clase cada vez que un método accede a las propiedades u otros métodos de
la clase.
Por ejemplo, observe en la clase Empleado que el método calcularPago()
accede a la propiedad salario, como se muestra:
public double calcularPago() {
return salario / 52;
}

La única forma de acceder a una propiedad o método de un objeto es tener una referencia al
objeto. Pero en el método calcularPago() no se usó ninguna referencia para acceder a la
propiedad salario. Simplemente se usó la propiedad salario y todo trabajó bien.
La razón por la cual todo trabajó bien es porque el compilador se da cuenta que calcularPago()
está accediendo a la propiedad salario, por lo que el compilador agrega la referencia. ¿Cuál
referencia agrega el compilador? Bien, calcularPago() necesita una referencia a cualquier objeto
que lo invoque, lo cual en cada caso es la referencia this.
El método calcularPago() es similar a lo siguiente:
public double calcularPago() {
return this.salario / 52;
}

Observe que la referencia this y el operador punto fueron prefijados a salario. El compilador
agrega la referencia this si usted no la coloca de manera explícita. Puede agregar la referencia this
si lo desea o simplemente puede dejar que el compilador lo haga por usted.
Por ejemplo, en la clase Empleado, el método enviarCheque() accede a las propiedades nombre y
direccion. En cada caso la referencia this es usada ya sea que la agregue al código o que el
compilador la agregue. El método enviarCheque() es similar a lo siguiente:
public void enviarCheque() {
System.out.println("Enviar cheque a " + this.nombre + "\n" + this.direccion);
}

Observe que las propiedades nombre y direccion están prefijados con this.

Página 7 de 10
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

LA PILA DE LLAMADA DEL MÉTODO.

Los métodos cambian el flujo de control de un programa.
Cuando un método es invocado (llamado) causa que el flujo
de control salte hacia el método que está siendo invocado.
El flujo de control entonces ejecuta las sentencias dentro del
método. Por supuesto que el método que se está ejecutando
puede invocar a otro método, causando que el flujo de
control salte hacia ese otro método. Todas las llamadas a
métodos son mantenidas en la pila de llamadas. Cuando este
método completa su ejecución es eliminado de la parte
superior de la pila de llamada y el flujo de control regresa al
método previo de la pila. Cuando un nuevo método es
invocado se coloca en la parte superior de la pila de llamada.
El primer método que es invocado en el programa Java es main(), el cual es invocado por la JVM.
Por tanto, main() se encuentra en el fondo de la pila de llamada de métodos.
Suponga que main() invoca a un método llamado encender() y que ese método invoca a un
método establecerVolumen(), el cual a su vez invoca al método println(). Ya que println() está en la
parte superior de la pila de llamada, el flujo de control actualmente se encuentra dentro de
println(). El método establecerVolumen() está esperando que println() finalice, el método
encender() está esperando que establecerVolumen() finalice, y así sucesivamente hasta el fondo de
la pila.

INVOCANDO UN MÉTODO.
Cuando se invoca a un método, Java lo coloca en la parte superior de la pila
de llamada hasta que finaliza su ejecución. Cuando un método ha
finalizado su ejecución, pueden suceder tres cosas:
1. El método devuelve un valor, en cuyo caso un tipo de datos
primitivo o de referencia es devuelto al punto desde donde se
invocó al método.
2. El método no devuelve ningún valor, en cuyo caso el valor de retorno es vacío.
3. El método arroja una excepción, la cual es devuelta al punto desde donde se hizo la
llamada al método.
En cualquiera de estos casos, el flujo de control regresa al punto desde donde se invocó al
método.

REGRESO DE UN MÉTODO.
En general, hay dos cosas que causan el regreso de un método:
1. Al encontrar la llave de cierre del método.
2. Al ejecutar la instrucción return.

Página 8 de 10
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

En un método void se puede usar la terminación inmediata de un método empleando la

instrucción return, tal como se muestra a continuación:
void unMetodo() {
int i;

for (i = 0; i < 10; i++) {

if (i == 5)
return;
System.out.println(i);
}
}

Cuando un método devuelve un valor se usa la palabra return y el valor devuelto debe coincidir
con el tipo de datos del método.

USO DE PARÁMETROS
Aunque los métodos con un tipo de retorno void no
son raros, casi todos los métodos devolverán un valor.
En realidad, la capacidad de regresar un valor es una de
las características más útiles de un método.
Es posible pasar uno o más valores a un método
cuando es llamado. Se le llama argumento al valor que
se envía al método. Dentro del método, se le llama parámetro a la variable que recibe el valor. Los
parámetros se declaran dentro del paréntesis que sigue al nombre del método.
class revisarNumero {
boolean esPar(int x) {
if (x % 2 == 0)
return true;
else
return false;
}
}

El programa de demostración quedaría así:

public class ParametrosDemo {
public static void main(String [] args) {
revisarNumero num = new revisarNumero();

if (num.esPar(10))
System.out.println("10 es par");
if (num.esPar(9))
System.out.println("9 es par");
if (num.esPar(8))
System.out.println("8 es par");
}
}

Página 9 de 10
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

CONSTRUCTORES.
Un constructor inicializa un objeto cuando se crea. Tiene el mismo
nombre que su clase y es sintácticamente similar a un método. Sin
embargo, los constructores no tienen un tipo de datos de retorno
explícito. Por lo general usará un constructor para dar valores
iniciales a las variables de instancia definidas por la clase o para
realizar cualquier otro procedimiento de inicio que se requiera para
crear un objeto completamente formado.
Todas las clases tienen constructores ya sea que los defina o no
porque Java proporciona automáticamente un constructor
predeterminado que inicializa todas las variables de miembros en cero. Sin embargo, una vez que
haya definido su constructor, el constructor predeterminado ya no se utilizará.
Ejemplo:
class unaClase {
int x;

unaClase() { // CONSTRUCTOR
x = 10;
}
}

CONSTRUCTORES CON PARÁMETROS.

Se puede escribir constructores que acepten uno o más parámetros.
Los parámetros se agregan al constructor de la misma manera en la
que se agregan a un método: sólo se les declara dentro del paréntesis,
después del nombre del constructor.
A continuación se presentan dos maneras de escribir parámetros en un
constructor. Tenga en cuenta que puede definir un listado de
parámetros en el encabezado del constructor.

class unaClase { class unaClase {

int x; int x;

unaClase(int a) { // CONSTRUCTOR unaClase(int x) { // CONSTRUCTOR

x = a; this.x = x;
} }
} }

Versión 1 Versión 2

Página 10 de 10