UT2.

JAVA

Página |1
TABLA DE CONTENIDO
¿Qué es Java? .................................................................................................. 3
Ventajas de Java. ..................................................................................................................................... 5
Desventajas de Java ................................................................................................................................. 5

Introducción a Java .......................................................................................... 6

Comentarios .................................................................................................................... 7
Identificadores ................................................................................................................ 7
Palabras reservadas ........................................................................................................ 7
Tipos de datos ................................................................................................................. 8
Modificadores ................................................................................................................. 9
Convenciones en la programación.................................................................................. 9

Capítulo 2 - El lenguaje .................................................................................. 11

Inicialización de variables ............................................................................................. 11
Expresiones lógicas ....................................................................................................... 11
Operadores y su Precedencia ....................................................................................... 11
Flujo de programa ......................................................................................................... 12
Sentencia if/else ..................................................................................................................................... 12
Sentencia switch .................................................................................................................................... 13
La sentencia for ...................................................................................................................................... 13
La sentencia while. ................................................................................................................................. 14
La sentencia do/while. ........................................................................................................................... 14
Paquetes ................................................................................................................................................ 15

Clases ............................................................................................................ 16
Conceptos básicos......................................................................................................... 16
Creación de una clase ................................................................................................... 16
Creación de un objeto ................................................................................................... 17
La referencia de variables y métodos con this ....................................................................................... 17

Sobrecarga de métodos ................................................................................................ 18

Constructores ................................................................................................................ 18
Subclases ....................................................................................................................... 19
Polimorfismo ................................................................................................................. 20
Redefinición de métodos .............................................................................................. 21

Página |2
 ¿QUÉ ES JAVA?
Hacia 1990, James Gosling, quien trabaja para Sun Microsystems, fue el
encargado de crear programas para controlar aparatos electrónicos domésticos.
Originalmente Gosling y su equipo empezaron el diseño de su software usando C++,
debido a su orientación a objetos. Sin embargo, se dieron cuenta que C++ no satisfacía
los proyectos que se tenían en mente; encontraron dificultades con aspectos
complicados de C++ como la herencia múltiple de clases, errores de programación
(bugs) relacionados con huecos de memoria. De esta manera Gosling decidió que tenía
que empezar por escribir un lenguaje simplificado que le evitara todos los problemas
que se encontró con C++.

Aunque a Gosling no le importó la complejidad de lenguajes como C++, tomo la

sintaxis básica y la orientación a objetos del lenguaje. Cuando terminó el nuevo
lenguaje lo llamó Oak (se cuenta que el nombre le vino a Gosling mientras veía un
roble por la ventana de su oficina.)

Oak se uso por primera vez en un proyecto llamado Proyecto Green, donde el
equipo de desarrollo intentó diseñar un sistema de control para usar dentro del hogar.
Este sistema de control permitiría al usuario manipular distintos dispositivos, como
televisiones, video caseteras, luces caseras y teléfonos, todo desde una computadora
de mano llamada *7 (Star Seven). El sistema *7 incluía una pantalla sensible para que
el dueño seleccionara y controlara estos dispositivos.

La pantalla del *7 tenía diversas figuras, entre las que se encontraba Duke (la
actual mascota de Java). Duke ha sido incluido en muchos ejemplos de applets en la
página de Sun Microsystems. El siguiente paso para Oak fue el proyecto Video En
Demanda (VOD), en el que el lenguaje era usado como la base para el software que
controlaría un sistema de televisión interactivo. Aunque ni *7 ni el proyecto VOD
concluyeron en productos actuales, le dieron a Oak una oportunidad de crecer y
madurar. Con el tiempo

Sun Microsystems descubrió que el nombre Oak ya había sido usado y le cambió
el nombre por Java, y vio nacer un lenguaje poderoso y sencillo.

Java es un lenguaje independiente de la plataforma, lo que significa que los

programas desarrollados en Java correrán en cualquier sistema sin cambios. Esta
independencia de plataforma se logró usando un formato especial para los programas
compilados en Java. Este formato de archivo, llamado "byte-code" puede ser leído y
ejecutado por cualquier computadora que tenga un intérprete de Java. Este intérprete
de Java, por supuesto, debe ser escrito especialmente para el sistema en el que
correrá.

En 1993, después de que Internet se transformó de un ambiente basado en texto

a un ambiente gráfico, el equipo de Java se dio cuenta de que el lenguaje sería
perfecto para la programación en el Web. Así nació la idea de los applets, que son
pequeños programas que pueden ser incluidos en páginas de Web, y también

Página |3
 surgió la idea de escribir un navegador de Web que demostraría el poder del
lenguaje, este navegador es el HotJava.

Finalmente, hacia mayo de 1995, Sun Microsystems anunció oficialmente a Java.

El nuevo lenguaje fue aceptado como una poderosa herramienta para el desarrollo de
aplicaciones para Internet. Netscape Communications, el creador del navegador
Netscape Navigator, dio soporte a Java desde su versión 2.0.

Otros desarrolladores de software también incluyeron soporte para Java,

incluyendo al Internet Explorer 3 de Microsoft. Actualmente, Java puede correr en
máquinas con procesadores SPARC, Intel, Digital.

De acuerdo con Sun Microsystems, Java es "simple, orientado a objetos,

tipificado estáticamente, compilado, independiente de arquitectura, multi-procesos,
con recolector de basura, robusto, seguro y ampliable."

Es simple porque los desarrolladores en Java deliberadamente dejan muchas de

las características innecesarias de otros lenguajes de programación de alto nivel. Por
ejemplo, Java no soporta aritmética de apuntadores, cast de tipos implícito,
estructuras o uniones, sobrecarga de operadores, plantillas, archivos de cabecera o
múltiple herencia.

Es orientado a objetos, porque como C++, Java usa clases para organizar el
código en módulos. En tiempo de ejecución, un programa crea objetos a partir de las
clases. Las clases en Java pueden heredar de otras clases, pero la múltiple herencia,
donde una clase hereda métodos y datos de varias clases, no está permitida.

Es tipificado estáticamente porque todos los objetos usados en un programa

deben ser declarados antes de que puedan ser usados. Esto permite al compilador de
Java localizar y reportar conflictos con los tipos de datos.

Es compilado porque antes de que se pueda correr un programa, primero tiene

que ser compilado por el compilador de Java. El resultado de la compilación es el
archivo "byte-code", que, similar a un archivo con código máquina, puede ser
ejecutado bajo cualquier sistema operativo que tenga un intérprete de Java. Este
intérprete lee el archivo byte-code y traduce los comandos en comandos de lenguaje
máquina que pueden ser ejecutados directamente por la computadora.

Es multiprocesos porque los programas de Java pueden contener múltiples

procesos en ejecución, lo que permite a los programas manejar varias tareas
simultáneamente. Por ejemplo, un programa multiprocesos puede definir una imagen
(render) en un proceso mientras continua aceptando entrada del teclado en el proceso
principal. Todas las aplicaciones tienen al menos un proceso (llamado thread) que
representa la ejecución del programa.

Tiene recolector de basura, ya que los programas de Java no se encargan de

liberar de memoria los objetos, esto es una tarea del administrador de memoria y el
recolector de basura.

Página |4
 Es robusto porque el intérprete de Java revisa todos los accesos al sistema
dentro de un programa, por esto, los programas desarrollados en Java no pueden tirar
el sistema. Esto es, cuando un error serio es encontrado, los programas en Java crean
una excepción. Esta excepción puede ser capturada y manejada por el programa sin el
riesgo de bloquear el sistema.

Es seguro porque el compilador no sólo verifica todos los accesos a memoria,

sino que también se asegura que no entren virus en un applet en ejecución. Ya que los
apuntadores no son soportados por el lenguaje, los programas no pueden acceder a
áreas del sistema a las que no tienen autorización.

Es ampliable porque los programas en Java soportan métodos nativos, que son
funciones escritas en otros lenguajes, generalmente C++. Este soporte a métodos
nativos permite a los programadores escribir funciones que pueden ser ejecutadas
más rápido que las funciones equivalentes escritas en Java. Los métodos nativos son
ligados a los programas en forma dinámica, es decir, son asociados con los programas
en tiempo de ejecución.

VENTAJAS DE JAVA.

 Es seguro.
 Se aprende con facilidad. Soportado por Microsoft.
 Es orientado a objetos.
 No bloquea el sistema.
 Aplicaciones para comunicación en red.
 No tiene aritmética de apuntadores.
 Es independiente de la plataforma.

DESVENTAJAS DE JAVA

 Es 10 a 20 veces más lento en ejecución que C++.

Página |5
 INTRODUCCIÓN A JAVA
Java tiene las siguientes características:

 La Máquina Virtual de Java (JVM)

 Recolección de basura
 Seguridad en el código

La especificación de la Máquina Virtual de Java define a ésta como:

"Una máquina imaginaria que es implantada por la emulación de software en

una máquina real. El código para la JVM es almacenado en archivos .class, cada uno
contiene código para al menos una clase pública".

Esta especificación permite a los programas Java ser independientes de la

plataforma porque la compilación es hecha por una máquina genérica. Al intérprete de
Java de cada plataforma de hardware le corresponde asegurar la ejecución del código
compilado para la JVM.

Muchos lenguajes de programación permiten el alojamiento dinámico de

memoria en tiempo de ejecución. Este proceso varía en la sintaxis de los lenguajes,
pero siempre hay un valor de retorno de un apuntador a la dirección de inicio del
bloque de memoria. Una vez que la memoria ocupada ya no se necesita, el programa o
el ambiente de ejecución debería liberar la memoria para prevenir que el programa
corra sin memoria disponible.

En C y C++ (y otros lenguajes), el programador es responsable de liberar la

memoria. Esto puede ser tedioso, porque no se sabe con anticipación cuando se va a
liberar memoria. Los programas que no liberan memoria pueden bloquear el sistema
cuando no queda memoria disponible. Java quita esa responsabilidad de liberar
memoria explícitamente integrando un proceso a nivel de sistema que sigue cada
alojamiento de memoria y mantiene una cuenta del número de referencias a cada
apuntador a memoria. Durante los intervalos de tiempo de ocio en la JVM, el proceso
de recolección de basura revisa si hay apuntadores a memoria donde el número de
referencias es igual a cero. Si hay algunos, el bloque de memoria marcado por el
recolector es liberado.

Una vez compilados los programas en Java, en el momento de ejecución se lleva

a cabo una tarea de carga, revisión y ejecución. La carga consta de cargar en memoria
el archivo byte-code, puede cargarse desde la máquina local o remotamente a través
de la red. La revisión consta de verificar que no haya: violaciones de acceso,
operaciones que conduzcan a "overflow" o "underflow", tipos de parámetros
incorrectos, conversiones de datos incorrectas, acceso a objetos sin inicializar, entre
otras funciones. En el proceso de ejecución ya se corren las instrucciones del
programa.

Página |6
 Comentarios
Los comentarios en Java se pueden escribir en tres formas:
// comentario de una línea
/* comentario de una o más líneas */
/** comentario para documentación */

Los comentarios de documentación se colocan justo antes de la variable o

función. Estos sirven para el programa javadoc, el cual genera archivos html, y sirven
como una descripción del tópico declarado.

Identificadores
En Java, un identificador empieza con una letra, el carácter de subraya o el signo
$. Los demás caracteres pueden contener dígitos. Todos los identificadores son
sensibles a mayúsculas / minúsculas.

Ejemplos de identificadores validos:

variable
nombreUsuario
Nombre_Usuario
_numero
$cadena

Los últimos tres ejemplos son muy poco usados en la generalidad de los
programas. Los identificadores pueden contener palabras reservadas, pero no pueden
ser palabras reservadas; por ejemplo, es valido integer, pero no int.

Palabras reservadas
abstract do implements private throw
boolean double import protected throws
break else instanceof public transient
byte extends int return true
case false interface short try
catch final long static void
char finally native super volatile
class float new switch while
continue for null synchronized
default if package this

Nota.- En Java, true, false y null se escriben en minúsculas, al contrario que en

C++.

No existe un operador sizeof; el tamaño y representación de todos los tipos es

fija y no es dependiente de la implantación.

Las palabras goto y const no se usan en Java.

Página |7
 Tipos de datos
Java define ocho tipos de datos primitivos y uno especial. Se pueden agrupar en:
lógicos, textuales, integrales y de punto flotante.

El tipo de dato boolean sólo tiene dos valores: false y true. En C/C++ se permite
que valores numéricos sean interpretados como valores lógicos, pero no es el caso de
Java; sólo se permiten valores lógicos.

Los tipos de datos textuales son: char y String. Los caracteres se representan por
el tipo de dato char, usando un número de 16 bits sin signo con un rango de cero a
216−1 . Los caracteres se encierran entre apóstrofes.
'a' Letra a
'\t' Un tabulador

El tipo String, que no es primitivo, es usado para representar secuencias de

caracteres. Una cadena de caracteres se encierra entre comillas.
"Esto es un mensaje"

Los tipos integrales son: byte, short, int y long. Todos son números con signo. Los
números se pueden representar en forma decimal, octal o hexadecimal.
2 Valor decimal es dos
077 El cero que inicia indica un valor octal
0xBC27 0x indica un valor hexadecimal

Para especificar un valor long se debe poner L al final del número. Se puede usar
l o L, pero en minúscula se puede confundir con el número 1 en algunos casos.
2L Valor decimal dos, como un valor largo
077L El cero que inicia indica un valor octal
0xBC27L 0x indica un valor hexadecimal

A continuación se presenta una tabla con los cuatro tipos de datos. La

representación del rango es definida por la especificación del lenguaje como un
complemento a dos y es independiente de la plataforma.

Tamaño Tipo Rango

8 bits byte 27 ... 27−1
16 bits short 215 ... 215−1
32 bits int 231 ... 231−1
64 bits long

Los tipos de dato para número de punto flotante son: float y double. Un valor en
punto flotante puede incluir el punto decimal, una parte exponente (letra E), o es
seguido por la letra F (float) o la letra D (double).
3.14 Valor de punto flotante
6.02E23 Valor de punto flotante muy grande
2.718F Valor sencillo de tipo float
123.4E+306D Valor de punto flotante muy grande de tipo double

Página |8
 Tamaño Tipo
32 bits float
64 bits double

En Java, todos los valores de punto flotante son double, a menos que se indique
explícitamente que sean float.

Por lo tanto, en los ejemplos anteriores:

2.718F debe llevar la letra F para mantenerlo como float
123.4E+306D la D es redundante

Modificadores
Dentro de las palabras reservadas, Java utiliza las siguientes para modificar el
acceso a una variable, clase o función y se colocan al inicio de la declaración: public,
protected, default, private.

El modificador public da acceso a cualquier objeto externo.

public int numero; // cualquier objeto puede accesar a esta variable

El modificador protected da acceso a objetos que son parte del mismo paquete,
y las subclases. (Más adelante se explica el concepto de paquete)

El modificador default da acceso a objetos que son parte del mismo paquete. Sin
embargo, en los programas no se especifica el modificador porque no hay una palabra
para ello.
int numero; // acceso default

El modificador private da acceso únicamente a la clase que lo contiene.

private int numero; // únicamente lo puede accesar la clase

Convenciones en la programación
Clases.- Los nombres de las clases deberían ser sustantivos, utilizando
mayúsculas para la primera letra y minúsculas para las restantes, y se pueden mezclar
varios sustantivos.
class CuentaBancaria

Interfaces.- Los nombres de las interfaces deberían tener la primera letra

mayúscula, como en los nombres de clase.
interface Cuenta

Métodos.- Los nombres de los métodos deberían ser verbos, todo el verbo en
minúscula. Se pueden agregar sustantivos con la primera letra en mayúscula. Evitar el
uso de subrayas.

Página |9
void revisarCuenta()

Constantes.- Las constantes de tipos de datos primitivos deberían escribirse

completamente en mayúsculas y separadas las palabras por subrayas. Las constantes
de objeto pueden combinar mayúsculas y minúsculas
final int MAX_CREDITO

Variables.- Todas las variables deberían ser en minúsculas, y si se agregan

palabras se separarán con una letra mayúscula. Evitar el uso del signo $.
primerUsuario

Las variables deben tener significado e indicar su uso. Las variables de una letra
deberían evitarse, excepto las que suelen usarse en ciclos (x, y, i, j, m, n) para
controlarlo.

Otras convenciones de la programación incluyen el uso de llaves ({}) alrededor de

un bloque de instrucciones, incluso cuando se trate de una sola instrucción, ya que
esto ayuda en el mantenimiento del programa.
if(condición) {

bloque
}

El espaciado ayuda en la comprensión del programa. Se sugiere escribir una

instrucción por línea y usar indentación de uno o dos espacios.

Los comentarios también ayudan en la comprensión y mantenimiento del

programa al dar una descripción clara de lo que hace cada función y el uso de las
variables.

Ejemplo:
// primer programa en Java
public class HelloWorld {
public static void main(String argv[]) {
System.out.println("Hello world!");
}
}

P á g i n a | 10
 CAPÍTULO 2 - EL LENGUAJE
Inicialización de variables
Java no permite que una variable tenga un valor indefinido. Cuando un objeto es
creado, sus variables son inicializadas con los siguientes valores:
byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0D
char '\u0000' (NULO)
boolean false
todas las referencias null

Si algún objeto hace referencia a algo con valor de null, creará una excepción (un
error que es manejable).

Para evitar que las variables tengan valores indeseables, se debe asignárseles
algún valor útil. El compilador estudia el código para determinar que cada variable ha
sido inicializada antes de su primer uso. Si el compilador no puede determinar esto,
entonces ocurre un error en tiempo de compilación.
public void calcula() {
int x = (int)(Math.random() * 100);
int y;
int z;
if(x > 50) {
y = 9;
}
z = y + x;
// el posible uso antes de la inicialización de y creara un error
de compilación
}

Expresiones lógicas
Los operadores relacionales y lógicos regresan un valor boolean.
int i = 1;
if(i) // error en tiempo de compilación
if(i != 0) // correcto

Operadores y su Precedencia
Los operadores en Java son muy similares en estilo y función a aquellos en C y
C++. La siguiente tabla en lista los operadores por orden de precedencia:
Separador . [] () ; ,
D a I ++ -- + - ~ !

P á g i n a | 11
I a D * / %
I a D + -
I a D << >>
I a D < > <= >= instanceof
I a D == !=
I a D &
I a D ^
I a D |
I a D &&
I a D ||
D a I ?:
D a I = *= /= %= += -= <<= >>= &= ^= |=

El operador + se puede utilizar para concatenar cadenas de caracteres,

produciendo una nueva:
String saludo = "Sr. ";
String nombre = "Luis " + "Torres";
String persona = saludo + nombre;

Los operadores && (and) y || (or) realizan una evaluación corta en expresiones
lógicas.

Cast

Cuando la asignación de valores no es compatible por los tipos de datos, se usa

un cast para persuadir al compilador de reconocer tal asignación. Esto se puede hacer
para asignar un long a un int, por ejemplo.
long bigValue = 99L;
int smallValue = (int)bigValue;

No es necesario el segundo grupo de paréntesis, los que encierran a bigValue,

pero es muy recomendable dejarlos.

Aunque short y char ocupan 16 bits, se debe hacer un cast explícito, debido al
rango que tienen asignado.

Flujo de programa

SENTENCIA IF/ELSE

Permite elegir una de dos opciones. La sintaxis básica de la sentencia if/else es:
if(condición) {
//instrucción_o_bloque
}
else {
//instrucción_o_bloque
}

Ejemplo:
int aleatorio = (int)(Math.random() * 100);

P á g i n a | 12
if(aleatorio < 50) {

System.out.println("menor a 50");
}
else {

System.out.println("mayor o igual a 50");

}

SENTENCIA SWITCH

Permite seleccionar una de varias opciones. La sintaxis para switch es la

siguiente:
switch(expresión_a_evaluar) {

case valor1:
instrucciones;
break;
case valor2:
instrucciones;
break;
case valor3:
instrucciones;
break;
default:
instrucciones;
break;
}

El valor de expresion_a_evaluar debe ser compatible con el tipo int, como short,
byte y char. No se permite evaluar long o valores de punto flotante.

Ejemplo:
switch(colorNum) {
case 0:
setBackground(Color.red);
break;
case 1:
setBackground(Color.green);
break;
case 2:
setBackground(Color.blue);
break;
default:
setBackground(Color.black);
break;
}

LA SENTENCIA FOR

Permite realizar una serie de instrucciones mientras se cumple una condición. La

sintaxis básica para for es:
for(inicialización;condición;alteración) {

P á g i n a | 13
 instrucciones;
}

Ejemplo:
int x;
for(x = 0;x < 10;x++) {

System.out.println("dentro de for");
}
System.out.println("fin de for");

El tercer parámetro puede ser tanto de incremento como de decremento, y no

únicamente de uno en uno. Java permite el uso de comas dentro de la declaración de
for, como en C, por lo que lo siguiente es legal:
for(i = 0, j = 0;j < 10;i++,j++)

En el ejemplo anterior, la variable x es "visible" en el método en el que es

declarada. Se puede usar una variable que sea visible únicamente para el ciclo for:
for(int x=0;x<10;x++) {
...
}
// una vez terminado el ciclo, x ya no puede ser accesada

LA SENTENCIA WHILE.

Permite realizar una serie de instrucciones mientras se cumple una condición. La

sintaxis básica de while es:
while(condición) {

instrucciones;
}

Ejemplo:
int i = 0;
while(i<15) {

System.out.println("dentro de while");
i+=2;
}

LA SENTENCIA DO/WHILE.

Permite realizar una serie de instrucciones hasta que deje de cumplirse una
condición. La sintaxis básica de la sentencia es:
do {

instrucciones;
}while(condición);

P á g i n a | 14
 Ejemplo:
int i = 0;
do {

System.out.println("dentro de while");
i++;
}while(i<10);

PAQUETES

Java provee el mecanismo de paquetes (package) como una forma de organizar

las clases. Se puede indicar que las clases en el código fuente van a pertenecer a un
paquete empleando la palabra package.
package empresa.sistemas;
public class Empleado {

...
}

La declaración de paquete, si la hay, debe estar al inicio del código fuente, puede
estar precedida únicamente de comentarios. Solo se permite una declaración package
por archivo fuente. Los nombres de los paquetes son jerárquicos, separados por
puntos. Por lo general, los elementos de los paquetes son escritos enteramente en
minúsculas. Una vez compilado el archivo, puede ser usado por otro mediante la
sentencia import, que indica donde se encuentran los paquetes. Import debe preceder
a todas las declaraciones de clases.
import empresa.sistemas.*;
public class JefeArea extends Empleado {

String departamento;
Empleado subordinados[];
...
}

P á g i n a | 15
 CLASES
Conceptos básicos
Una clase es la definición de las tareas que se van a realizar. Incluye las variables
necesarias y los métodos, tanto públicos como privados.

Un objeto es la instancia, una concreción de una clase. Con un objeto se pueden

ejecutar las tareas definidas en la clase.

Una subclase es una clase que se deriva de otra, que hereda de otra sus variables
y métodos.

Constructor es el método que da valores iniciales al objeto al momento de

hacerse la instancia.

Herencia es la capacidad de recibir todos los métodos y variables de una o más

clases para realizar ciertas tareas. Por lo general, las subclases agregan métodos y
modifican algunos métodos para realizar tareas diferentes. Por ejemplo, la clase Object
(de la que heredan todas las demás clases en Java) define un método llamado
toString() que regresa la representación textual del objeto. Cada clase modifica en
cierta manera el comportamiento de toString() para regresar valores de acuerdo a la
tarea para la que fue creada la clase.

Encapsulamiento es la característica de organizar datos y funciones en una

estructura. Además esto permite ocultar código para facilitar la programación y
mantenimiento. Las variables casi siempre son privadas, ya que dejar que un objeto
ajeno modifique el valor de una variable puede conducir a un mal funcionamiento del
objeto que contiene esa variable o se pueden presentar resultados indeseables.

Polimorfismo es la capacidad de un objeto de asumir diferentes formas pero aun

siendo compatible en tipo con el código existente.

Creación de una clase

Una clase debe tener la siguiente sintaxis:

[<modificador>] class <nombre_de_clase>

En Java, generalmente se crean clases public o default. Y en un código fuente

sólo puede haber una clase public. El siguiente es un ejemplo sencillo de creación de
una clase:
public class Fecha
{
private int dia,mes,anio;
public void manana()
{

P á g i n a | 16
// calcular el día siguiente
}
}

Creación de un objeto
Para que se puedan realizar las tareas que define la clase Fecha, se tiene que
hacer una instancia de la clase:
Fecha fecha;
fecha = new Fecha();
// tal vez el constructor ya definió la fecha actual
fecha.manana();
// dentro del código de tomorrow se calcula el día siguiente

Si definimos otra variable de tipo Fecha y le asignamos el valor de fecha, Java no

crea un nuevo objeto, sino que ambas variables apuntan a la misma localidad de
memoria:
Fecha fecha1,fecha2;
fecha1 = new Fecha();
fecha2 = fecha1;

En memoria esto se vería así:

fecha1 Fecha
fecha2

LA REFERENCIA DE VARIABLES Y MÉTODOS CON THIS

En Java la palabra reservada this se usa para accesar variables y métodos del
mismo objeto (ya creado) para

facilitar la programación. this no se puede usar con llamadas static de métodos.

public class Fecha {

private int dia,mes,anio;

public void manana() {
this.day = this.day + 1;
// más código
}
}

En este ejemplo resulta redundante el uso de this, pero puede entenderse que
this.day es la variable de la clase. En el siguiente ejemplo se fija un número de día
pasando un parámetro al método fijaDia():
public class Fecha {
private int dia,mes,anio;
public void fijaDia(int dia) {
this.dia = dia;
}
}

P á g i n a | 17
 Este ejemplo es completamente válido y legal, ya que el primer elemento de la
asignación se refiere a la variable de la clase, y el segundo elemento de la asignación se
refiere al parámetro del método fijaDia.

Sobrecarga de métodos
En ciertas circunstancias, uno desea escribir varios métodos en la misma clase
que hagan básicamente lo mismo pero con diferentes parámetros. Considérese el
ejemplo en el que se quiere imprimir la representación textual de un parámetro, por
ejemplo el método print().

Este método podría recibir como parámetros un int, long, double, String, etc. Es
posible que cada tipo de dato requiera de alguna conversión para poder imprimir su
valor como cadena de caracteres. En lenguajes estructurados, la solución sería crear
funciones printint(), printfloat(), printString(), pero sería una tarea tediosa.

Reusando el nombre del método, se tienen las siguientes definiciones:

public void print(int i)
public void print(double d)
public void print(String s)

En tiempo de ejecución, el programa sabe a que método llamar dependiendo del

tipo de dato del argumento:
clase.print(5);
clase.print(3.14159264);
clase.print("mensaje");

Constructores
Un método constructor, como ya se dijo, es el que se encarga de dar ciertos
valores iniciales a las variables de la clase.

Existen dos reglas importantes para los constructores:

1) El nombre del método debe ser exactamente el mismo que el de la clase.

2) No se debe declarar tipo de dato de regreso del método.
public class Clase {
// variables de la clase

public Clase() {

// inicialización de algunas variables

}

public Clase(int x) {
// inicialización del objeto con un parámetro
}
}
Clase c,d;
c = new Clase();

P á g i n a | 18
d = new Clase(1);

Como se ve en el ejemplo anterior, los constructores también se pueden

sobrecargar para poder recibir cualquier cantidad de parámetros y los parámetros
pueden ser de diferentes tipos. En tiempo de ejecución, el programa sabe a que
constructor llamar.

Cada clase tiene al menos un constructor. Si no se define uno, Java lo crea

automáticamente sin parámetros ni código. De no ser así, se tendría que definir al
menos un constructor para poder crear la instancia del objeto.

Si en una clase se definen constructores con parámetros, se pierde el constructor

que crea Java, por lo que una llamada a new Clase() generaría un error de compilación.

Subclases
En Java todas las clases son subclases de Object. Se crean subclases para realizar
tareas específicas a partir de una clase padre que contiene información básica
(variables y métodos). Por ejemplo, se puede crear la clase

Empleado y luego crear subclases con características específicas.

public class Empleado {

private String nombre;

private Date fechaNacimiento;
private String puesto;
...
}

public class Gerente {

private String nombre;
private Date fechaNacimiento;
private String puesto;
private String departamento;
private Empleado subordinados[];
...
}

En este ejemplo se muestra la duplicidad de información entre las clases

Empleado y Gerente. Y no solo en las variables, también habrá métodos que se
dupliquen, por ejemplo el del cálculo de antigüedad.

Por lo tanto, se puede ver que la clase Gerente tiene las mismas y más
características y acciones que la clase Empleado, por lo que es posible crear una
subclase Gerente que herede de Empleado.
public class Empleado {

private String nombre;

private Date fechaNacimiento;
private String puesto;
...
}

P á g i n a | 19
public class Gerente extends Empleado {
private String departamento;
private Empleado subordinados[];
...
}

Se usa la palabra reservada extends para indicar la herencia de una clase a otra,
en este ejemplo la clase Gerente "extiende" a la clase Empleado en variables y
métodos extra. Ahora la clase Gerente tiene las mismas características que Empleado y
además otras que son propias para esa clase. La clase Gerente heredó de la clase
Empleado sus variables y métodos.

Las subclases permiten claridad y mantenimiento en la programación. Si se hace

una corrección en la clase Empleado, la clase Gerente es corregida sin que el
programador haya trabajado doble.

Polimorfismo
Siguiendo con el ejemplo de las clases Empleado y Gerente, se puede tener un
método calculaSalario() en la clase Empleado, por lo que también se hereda a Gerente.
Esto lleva a la idea de que los objetos son polimórficos. Un objeto en particular puede
tener la forma de Gerente, pero también tiene la forma de Empleado.

Para ver un efecto del polimorfismo con estas clases, se puede crear un arreglo
que contenga tanto empleados como gerentes:
Empleado staff[] = new Empleado[100];
staff[0] = new Gerente();
staff[1] = new Empleado();

Esto crea un arreglo heterogéneo, es decir, una colección de objetos diferentes.

También en el paso de parámetros el polimorfismo toma importancia. Considérese el
cálculo de antigüedad:

public int calcularAntiguedad(Empleado e) {

// calcular
}
Gerente g = new Gerente();
int antiguedad = calcularAntiguedad(g);

Al principio puede parecer ilógico crear un gerente y calcular su antigüedad

como empleado. En este caso se uso la clase Empleado como objeto genérico en el
parámetro de calcularAntiguedad(), porque un Gerente es un Empleado, pero un
Empleado no es un Gerente.

Cast de objetos y la palabra reservada instanceof

Se usa la palabra reservada instanceof para determinar a que clase pertenece el

objeto que está siendo

utilizado en cierto momento. Por ejemplo:

P á g i n a | 20
public class Empleado

public class Gerente extends Empleado

public class Director extends Empleado

public void quien(Empleado e) {

if(e instanceof Gerente) {

// jefe inmediato superior

}
else if(e instanceof Director) {

// toma decisiones importantes

}else {

// le puedo hablar de tu
}
}

Dentro de este bloque de código se pueden llamar métodos específicos de cada

objeto. Para hacer esto se crea una instancia de la clase apropiada usando un cast, y se
llaman a los métodos que se requieran:
public void quien(Empleado e) {

if(e instanceof Gerente) {

Gerente g = (Gerente)e;
System.out.println("Gerente del departamento " + g.departamento);
}
}

Esto permite que el programa compile y corra sin errores. Se tiene que hacer la
instancia porque la variable departamento no pertenece a la clase Empleado:
System.out.println(e.departamento); // error!

Redefinición de métodos
Además de heredar los métodos de una clase padre, se puede modificar la acción
de cualquier método, con el fin de mejorar o ampliar esa acción.

La regla que se debe seguir para redefinir un método es que el tipo de dato de
retorno y el número y tipo de datos de los parámetros tiene que ser idéntico al
definido en la clase padre. Sigamos con una variación del

ejemplo de Empleado y Gerente:

public class Emplead {

private String nombre;

private int salario;

public String obtenDetalles() {

return "Nombre: " + nombre + "\n" + "Salario: " + salario;
}

P á g i n a | 21
}

public class Gerente extends Empleado {

private String departamento;
public String obtenDetalles() {
return "Nombre: " + detalles + "\n" + "Departamento: " +
departamento;
}
}

La clase Gerente tiene un método llamado obtenDetalles() porque lo hereda de

Empleado. El método original ha sido redefinido o reemplazado para regresar un
mensaje diferente.

Por ultimo, una comparación entre Java y C++ con respecto a lo visto en este
Capítulo. En C++ se puede redefinir un método marcándolo como virtual en el código
fuente. En lenguajes puros orientados a objetos esto no es normal. C++ hace esto para
incrementar la velocidad de ejecución.

P á g i n a | 22