programación orientada a objetos en java

Informtica

edici

ones

de la

Luis Fernando Garca Llins

ientada a objetos en Java

edici

ones

de la

Este texto est dirig

ido a personas con

conocimientos pre

vios en programaci

n

que emplean el parad

igma procedimenta

l

para la codificaci

n de solucione

s

(especialmente usan

do el lenguaje C),

y que, adems, des

een aprender acerc

a

del desarrollo de ap

licaciones orientada

s

a objetos en Java

, sin necesidad de l

eer

la abundante y ext

ensa literatura que

,

por lo general, con

tienen los manuale

s

y guas de usuario

s. Precisamente, la

sntesis y la precisi

n de la informacin

,

es uno de los atract

ivos de este texto q

ue

compila en 260 p

ginas los contenido

s

bsicos para un cu

rso de programacin

orientada a objetos

en Java.

Pro

gram

aci

n or

ient

ada

a ob

jeto

s en

Jav

a

Luis Fernando Garca Llins

Luis

Fern

ando

Gar

ca

Llin

s

Aplicar el programa orientado a objetos

Codificar interfaces y grficas de usuario sencillas y atractivas

Disear a partir de teoras bsicas

Ejemplos y casos prcticos

Ingeniero de Sistemas, Universidad del Norte (Barranquilla). Magster en Ingeniera de Sistemas y Computacin con nfasis en Ingeniera de Informacin, Universidad de los Andes (Bogot). Desde el 2005 est vinculado a la Universidad del Norte como docente del Departamento de Ingeniera de Sistemas y Computacin, y actualmente hace parte del grupo de investigacin Redes de Computadores e Ingeniera de Software - GReCIS de esta misma institucin.

9 789587 410624

Programacin or

Todo lo bsico que debera saber sobre

Programacin orientadaa objetos en Java

Todo lo bsico que debera saber sobre

Programacin orientadaa objetos en Java

LUIS FERNANDO GARCA LLINS

2 0 1 0

Ediciones Uninorte, 2010 Ediciones de la U, 2010 Luis Fernando Garca Llins, 2010

Coordinacin editorialZoila Sotomayor O.

Diseo y diagramacinNilson Ordoez

Diseo de portadalvaro Bernal

Correccin de textosMercedes Castilla

Garca Llins, Luis Fernando. Todo lo que debera saber sobre programacin orientada a objetos en Java / Luis Fernando Garca Llins. Barranquilla : Ediciones Uninorte ; Grupo Editorial Ibnez, 2010.

258 p. ; 16 x 24 cm. ISBN 978-958-741-062-4

1. Java (Lenguaje de programacin de computadores). 2. Programacin orientada a objetos (Computadores). I. Tt.

(005.117 G216 Ed. 22) (CO-BrUNB)

www.uninorte.edu.coKm 5 va a Puerto Colombia, A.A. 1569,Barranquilla (Colombia)

http://edicionesdelau.com/Calle 24A n. 43-22Bogot (Colombia)

Impreso y hecho en ColombiaX-press Proceso BogotPrinted and made in Colombia

JAVA MK.indd 4 13/08/2010 06:46:45 p.m.

v1. TPICOS BSICOS ..................................................................................................... 11.1. Sobre el paradigma de programacin estructurada o procedimental ............ 1

1.2. Objeto ...................................................................................................................................... 5

1.3. Clase .......................................................................................................................................... 6

1.4. Atributo ................................................................................................................................... 7

1.5. Instanciacin .......................................................................................................................... 12

1.6. Mtodo ..................................................................................................................................... 22

Mtodo constructor, 29

1.7. Encapsulamiento .................................................................................................................. 39

1.8. Atributos finales ................................................................................................................... 52

1.9. Atributos y mtodos estticos ......................................................................................... 54

1.10. Herencia ................................................................................................................................. 59

1.11. Mtodos y clases abstractas ........................................................................................... 96

1.12. Casting .................................................................................................................................... 105

1.13. Polimorfismo ........................................................................................................................ 107

1.14. Mtodos y clases finales ................................................................................................... 114

1.15. Herencia simple y mltiple ............................................................................................. 123

1.16. Interfaces ............................................................................................................................... 124

CONTENIDO

vi

Todo lo bsico que debera saber sobre Programacin orientada a objetos en Java

2. TPICOS AVANZADOS ............................................................................................. 1352.1. Colecciones ............................................................................................................................. 136

Listas, 144. Conjuntos, 154. Mapas, 157. Genricos, 159.

2.2. Manejo de excepciones ...................................................................................................... 171

Generacin y lanzamiento de excepciones, 174. Captura de excepciones, 177.

Definicin de excepciones personales, 179.

3. CREACIN DE INTERFACES GRFICAS DE USUARIO ..................................... 1993.1. Componentes grficos ........................................................................................................ 201

3.2. Layouts ...................................................................................................................................... 208

FlowLayout, 209. GridLayout, 211. BorderLayout, 213.

3.3. Bordes ....................................................................................................................................... 221

3.4. Manejo de eventos ............................................................................................................... 226

vii

PREFACIO

El aprendizaje del paradigma de la programacin orientada a objetos presenta considerables problemas a quienes estn acostumbrados a trabajar bajo el paradigma estructurado, sobre todo cuando estos tienen varios aos de experiencia. Quizs el cambio de mentalidad que se requiere o la gran cantidad de nociones que surgen acentan esta situacin.

Inicialmente la programacin orientada a objetos puede llegar a verse como un paradigma complejo o complicado, aun cuando en realidad lo que busca es organizar de mejor manera el cdigo de una aplicacin desarrollada con el enfoque procedimental. Esto con el fin de facilitar su entendimiento y, por ende, si es necesario, su modificacin.

La metodologa que se emplea en este libro para introducir los tpicos consiste en plantear un problema sumamente sencillo, luego entrar a resolverlo empleando la programacin estructurada y despus de forma progresiva ir desarrollando la aplicacin empleando la programacin orientada a objetos. Durante este proceso se van introduciendo cada una de las nociones ms importantes para adicionarlas al desarrollo de la solucin (en algunos casos se presentan ms ejemplos para lograr un mejor entendimiento de cada uno de los tpicos). Es realmente importante analizar cmo se va configurando la solucin orientada a objetos y compararla con la solucin estructurada.

ObjetivOs

Ser conciso. Uno de los principales objetivos de este libro era escribirlo de manera sumamente concisa, es decir que no excediera las 250 pginas. Por eso nicamente se tocan los temas bsicos de la codificacin de aplicaciones orientadas a objetos empleando a Java como lenguaje de programacin. Por consiguiente, se excluyen temas como el trabajo con redes, la interaccin con bases de datos, el desarrollo de aplicaciones para la web, etc.

Servir como punto de partida. En ningn momento este libro pretende reemplazar textos ms robustos y completos que tratan estos y muchos otros tpicos. Ms bien se presenta como un punto de partida para los programadores y un eficaz complemento de otros textos, pues en la medida en que se comprenda la totalidad de esta obra ser mucho ms sencillo entender cualquier otra que trate los mismos temas.

viii


A quin vA dirigidO este librO?

Este libro fue ideado como texto gua para un curso de programacin orientada a objetos donde llegan estudiantes con nociones bsicas de programacin y conocimiento de la teora de algunas estructuras de datos. Por consiguiente, la obra se dirige especialmente a programadores que emplean el paradigma procedimental como principal aproximacin a la codificacin de soluciones (sobre todo empleando C como lenguaje de programacin), y que desean aprender las nociones del desarrollo de aplicaciones orientadas a objetos empleando Java.

qu se requiere Antes de leerlO?

Descargar e instalar la mquina virtual de Java que puede ser obtenida de forma gratuita de la web oficial de Sun (http://java.sun.com/javase/downloads/index.jsp)

Leer del Tutorial oficial de Java (http://java.sun.com/tutorial) los apartados que llevan por ttulos About the Java Technology (http://java.sun.com/docs/books/tutorial/getStarted/intro/definition.htm) y Hello World! For Microsoft Windows (http://java.sun.com/docs/books/tutorial/getStarted/cupojava/win32.html).

Descargar e instalar un entorno de desarrollo (IDE) para Java. Esto facilitar en gran medida la codificacin de los ejemplos. Existen muchos entornos gratuitos entre los que sobresalen: Netbeans (http://www.netbeans.org/), JDeveloper (http://www.oracle.com/technology/products/jdev/index.html), y Eclipse (http://www.eclipse.org/).

OrgAnizAcin

El libro est organizado en tres captulos.

En el primer captulo se presentan los tpicos bsicos de la programacin orientada a objetos. Tambin se analizan las nociones necesarias para la creacin de aplicaciones orientadas a objetos sumamente bsicas.

En el segundo captulo se presentan unos tpicos un poco ms avanzados de la teora de objetos. Aqu las nociones analizadas posibilitan la creacin de aplicaciones mas robustas y completas orientadas a objetos.

En el tercer captulo se presentan las teoras bsicas para disear y codificar interfaces grficas de usuario sencillas y moderadamente atractivas.

Adicionalmente, en todos estos captulos se incluye un conjunto de apartados donde se presentan explicaciones ms amplias, aclaraciones pertinentes o simplemente ejemplos ms completos de los tpicos que se abordan.

retrOAlimentAcin

Cualquier comentario, observacin, sugerencia o recomendacin que se desee efectuar sobre la presente obra ser bien recibida en las siguientes direcciones de correo electrnico: [email protected] o [email protected]

11. TPICOS BSICOS

1.1. sObre el pArAdigmA de prOgrAmAcin estructurAdA O prOcedimentAlDentro del mundo del desarrollo de aplicaciones bajo el paradigma estructurado (tambin conocido como programacin procedimental o tradicional) la idea general consiste en especificar el conjunto de instrucciones que brindan solucin a un problema especfico; este conjunto de instrucciones se definen al interior de las marcas de inicio y fin del bloque de codificacin principal del algoritmo. Durante el aprendizaje de este paradigma de programacin las recomendaciones iniciales son: entender el problema, definir las variables globales que harn parte de la solucin, identificar aquellas secciones de cdigo que conviene incluirlas dentro de funciones o subrutinas para futura reutilizacin, definir datos de entrada y de salida, entre otras.

Suponga que ha sido encargado del desarrollo de la aplicacin de software a una compaa que la desea para efectuar el clculo mensual de su nmina. Esta compaa contrata empleados a quienes les paga dependiendo del nmero de horas trabajadas y del valor por hora convenido previamente con cada uno. Como informacin bsica de cada empleado debe registrarse el nmero de la cdula, su nombre y su apellido.

Aclaraciones:

Tanto el valor del nmero de horas trabajadas por cada empleado como el valor de su sueldo por hora puede variar de un empleado a otro.

Se supondr que la aplicacin solo se requiere para calcular el valor de la nmina de un nico mes.

2Todo lo bsico que debera saber sobre Programacin orientada a objetos en Java

Para efectos de mantener la simplicidad del ejemplo no se contemplan acciones para manejar la persistencia 1 de los datos.

A continuacin una posible solucin al problema planteado empleando el paradigma estructurado.

Inicio

Entero: numeroEmpleados, i Caracteres: cedulas[50], apellidos[50], nombres[50] Real: horasTrabajadas[50], sueldoXHora[50] Caracteres: cedula, apellido, nombre Real: horas, sueldo Real: total

3que no se utiliza; sin embargo esta informacin se mantiene porque posteriormente puede ser til para ampliar la funcionalidad de la aplicacin.

Como la intencin es que sea un ejemplo didctico, inicialmente el algoritmo no contempla validaciones como impedir el doble ingreso de un mismo nmero de cdula.

CodifiCaCin en Java del algoritmo para el ClCulo de la nmina empleando programaCin estruCturada

Se presenta a continuacin la codificacin del ejemplo anterior aunque apenas se estn dando los primeros pasos en el aprendizaje del lenguaje de programacin Java. Esto porque es ms sencillo aprender a travs de ejemplos y del establecimiento de analogas, asociaciones y comparaciones.

import java.io.BufferedReader;import java.io.InputStreamReader; class Nomina { public static void main(String[] args) throws Exception { int numeroEmpleados; String[] cedulas = new String[50]; String[] apellidos = new String[50]; String[] nombres = new String[50]; double[] horasTrabajadas = new double[50]; double[] sueldoXHora = new double[50]; String cedula, apellido, nombre; double horas, sueldo; double total = 0; BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) );

System.out.print(Digite numero de empleados: ); numeroEmpleados = Integer.valueOf(br.readLine()).intValue(); for(int i=0;i


sueldo = Double.valueOf(br.readLine()).doubleValue(); cedulas[i] = cedula; apellidos[i] = apellido; nombres[i] = nombre; horasTrabajadas[i] = horas; sueldoXHora[i] = sueldo; }

for (int i=0;i

5 Es conveniente identificar cmo es el manejo de los arrays en Java y cmo se realiza la conversin entre tipos de datos.

En Java, los ndices de los arrays comienzan en el valor 0; es por ello que los contadores de los bloques de cdigo Para se inicializan en dicho valor, y llegan hasta el valor menos 1.

1.2. ObjetODentro del paradigma de desarrollo de aplicaciones orientadas a objetos cambia el enfoque de la solucin. Lo importante para el paradigma procedimental o estructurado es el bloque de cdigo principal (instrucciones dentro de la marca de inicio y fin). Para el paradigma orientado a objetos lo principal es entender y modelar el problema, y luego s definir el bloque de cdigo principal que empleando el modelo definido brinde solucin al problema especfico.

La programacin orientada a objetos requiere inicialmente identificar y modelar cada uno de los entes que hace parte del problema. Facilita la comprensin del tema hacerse una imagen mental de una posible situacin; por ejemplo, para el caso del clculo de la nmina suponga que la empresa cuenta nicamente con tres empleados cuya informacin se muestra en el siguiente grfico.

Para un programador con poca experiencia en la orientacin a objetos es moderadamente sencillo identificar que para el caso anterior los entes que toman parte del problema corresponden a los empleados de la empresa. En caso de que se necesite incluir un nuevo

1. TPICOS BSICOS


empleado en la empresa, aparecer otro objeto que seguramente poseer las caractersticas descriptivas de cdula, apellido, nombre, sueldo por hora y horas trabajadas, y dems valores para dichas caractersticas.

Es conveniente presentar una definicin para la nocin de objeto.

Definicin de objeto

Un objeto es un concepto, abstraccin o cosa con lmites bien definidos y con significado dentro del problema.

Como se puede apreciar la definicin de objeto es realmente amplia pues en realidad cualquier cosa puede ser un objeto. De all que puedan existir objetos que representen cosas concretas (como automviles, casas, libros, etc.) y objetos que representan cosas abstractas (como pensamientos, ideas, etc.).

1.3. clAsePara traducirlo a algn lenguaje de programacin se requiere una estructura de datos a fin de almacenar la informacin de cada uno de los objetos del problema. Sin embargo, no tiene sentido definir una estructura de datos independiente para cada uno de los posibles objetos de tipo empleado (como, por ejemplo, EstructuraTrabajor1, EstructuraTrabajador2, etc.), es ms conveniente definir una nica estructura de datos que pueda servir para almacenar la informacin de cualquier objeto del mismo tipo. La siguiente tabla muestra la informacin que debe permitir registrar esta estructura genrica y su correspondiente tipo de dato.

Campo Tipo dato Descripcin

cdula CaracteresEn este campo se registra el nmero de la cdula de ciudadana de un empleado.

apellido CaracteresEn este campo se registra la cadena de caracteres que corresponde al apellido de un empleado.

nombre CaracteresEn este campo se registra la cadena de caracteres que corresponde al nombre de un empleado.

horasTrabajadas RealEn este campo se registra el nmero de horas trabajadas por un empleado; por ejemplo, el valor de 1.5 indica que el empleado ha trabajado una hora y media (90 minutos).

sueldoXHora RealEn este campo se registra el valor que debe ser pagado a un empleado por cada hora de trabajo.

7Definicin de clase

Una clase describe a un conjunto de objetos que comparten una estructura y un comportamiento comn.

Una clase es un molde o plantilla que indica cmo ser un objeto de dicha clase. En el rea de la construccin, una clase podra ser el plano de una casa que indica la estructura que debe tener cada una de las casas, y los objetos son la materializacin de las casas construidas a partir de dicho plano. Es por ello que se define a un objeto como una instancia de una clase.

Para definir una clase en Java se utiliza la palabra reservada class. La sintaxis de dicha instruccin requiere adems de la especificacin de un nombre para la clase. La comunidad de programadores de Java maneja una convencin de nombramiento para las clases (ms que una regla es una simple sugerencia); dicha convencin establece que el nombre de la clase debe escribirse todo en minsculas a excepcin de la primera letra del nombre de la clase. Si para establecer el nombre de la clase se requieren varias palabras se deben unir las letras de todas las palabras y la primera letra de cada palabra debe estar en mayscula (por ejemplo, EmpleadoDeEmpresa). A continuacin se presenta el cdigo que permite definir en Java la clase para describir a objetos tipo empleado.

class Empleado{ String cedula; String apellido; String nombre; double horasTrabajadas; double sueldoXHora;}

Cada uno de elementos incluidos dentro de una clase recibe el nombre de atributos.

1.4. AtributO

Definicin de atributo

Un atributo es una propiedad que ayuda a describir un objeto.

Es conveniente tener en cuenta lo siguiente:

Hasta el momento y con las definiciones dadas, dos objetos distintos, pero de la misma clase tienen la misma estructura; es decir, comparten los mismos atributos, pero los valores para cada uno de los atributos son independientes.

1. TPICOS BSICOS


El orden de definicin de los atributos es irrelevante.

El concepto de atributo est estrechamente ligado al concepto de variable; en realidad todo atributo es un tipo de variable, sin embargo, no toda variable que pueda definirse en un programa en Java es un atributo.

Note que en Java para definir una variable se requiere, adems de un nombre2, su tipo de dato. La comunidad de programadores de Java maneja una convencin de nombramiento para los atributos (ms que una regla es una sugerencia), con la cual establece que el nombre del atributo debe escribirse en letras minsculas. Si el nombre del atributo est compuesto por varias palabras, se unen las letras de todas las palabras y se colocan en maysculas las primeras letras de cada palabra a excepcin de la primera letra del nombre del atributo (por ejemplo, horasTrabajadas).

Bsicamente los tipos de datos para los atributos (y variables) pueden ser de dos clases:

Tipo de dato primitivo3. Corresponde a un tipo de dato predefinido por el lenguaje. Cuando se define un atributo (o variable) de este tipo, entonces hay que separar un espacio en memoria para guardar su valor. Los ocho tipos de datos primitivos son: byte, short, int, long, float, double, boolean y char. Se hace relativamente sencillo inferir el propsito de cada uno de ellos. Es conveniente resaltar que el tipo de dato char corresponde a un solo carcter, lo que significa que no existe un tipo de dato primitivo en Java para una cadena de caracteres. La buena noticia es que existe String que no corresponde a un tipo de dato primitivo, sino a un tipo de dato de referencia.

Tipo de dato de referencia. Corresponde a un objeto de una clase (no obligatoriamente distinta a la definida). En este punto es donde radica gran parte de la importancia, flexibilidad y reutilizacin del paradigma de orientacin a objetos; porque cuando se definen atributos cuyo tipo sea una clase, se ampla el espectro de posibilidades. Cuando se define un atributo de este tipo no se separa espacio en memoria para un nuevo objeto, sino que se define una referencia que apuntar a un espacio de memoria con la estructura definida en la clase.

2 Detalles sobre la convencin de nombramiento de variables pueden ser consultados en la siguiente referencia: http://java.sun.com/docs/books/tutorial/java/nutsandbolts/variables.html

3 Mayor informacin sobre cada uno de estos tipos de datos puede ser consultada en la siguiente referencia: http://java.sun.com/docs/books/tutorial/java/nutsandbolts/datatypes.html

9sobre la ComposiCin de obJetos

Uno de los pilares fundamentales de la programacin orientada a objetos corresponde a la reutilizacin. Aqu la idea fundamental no es reinventar la rueda cada vez que se necesite, sino poder reutilizar la que ya esta inventada.

La siguiente podra ser una buena definicin para la clase Casa.

class Casa{ String colorTecho; String tipoTecho; double largoTecho; double anchoTecho; double altoTecho; String colorParedes; String tipoParedes; int numeroDeVentanas;}En la anterior definicin el atributo tipoTecho hace referencia al material con que est construido el techo de la casa, que puede tomar los valores de: paja, cinc, teja, etc.; similarmente,

el atributo tipoParedes hace referencia al material que compone las paredes de la casa, por ejemplo: ladrillo, madera, barro, etc. El resto de la anterior definicin de la clase Casa no es demasiado compleja y la mayora de los atributos se entienden fcilmente.

Una definicin alternativa para modelar una casa podra ser la siguiente:

class Techo{ String color; String tipo; int largo; int ancho; int alto;}

1. TPICOS BSICOS

10


class Pared{ String tipo; String color;}

class Casa{ Techo elTecho; Pared lasParedes; int numeroDeVentanas;}

Note que en este caso para lograr la definicin de la clase Casa ha sido necesaria la previa definicin de las clases Techo y Pared. Adicionalmente cabe resaltar que en la clase Casa existe un atributo de tipo de referencia de clase Techo cuyo nombre es elTecho, y, adems, existe un atributo de tipo de referencia de la clase Pared de nombre lasParedes.

Cul de las dos definiciones es la mejor? Depende del problema. La primera definicin de la

clase Casa es simple y sencilla de trabajar, pero no muy reutilizable. La segunda es un poco ms compleja, aunque ms reutilizable (imagine que se necesita la clase Edificio, para la cual se podran reutilizar algunas clases como Pared y Techo).

11

sobre la definiCin y manipulaCin de los tipos de datos primitivos y los de referenCia

Es realmente importante tener claridad sobre los tipos de datos de los atributos pues Java trata de forma muy distinta a cada uno de ellos.

Imagnese un objeto de la clase Casa donde solo se utilicen datos primitivos (la primera definicin que aparece en el apartado sobre la composicin de objetos). Java reservara espacio en memoria de la siguiente manera (el texto en la parte superior del rectngulo es simplemente para denotar la clase del objeto):

: CasacolorTecho = NegropoTecho = tejalargoTecho = 15anchoTecho = 10altoTecho = 2.5colorParedes = RojopoParedes = ladrillonumeroDeVentanas = 3

Para la segunda definicin de la clase Casa (en el ejemplo donde se usa composicin en el apartado sobre la composicin de objetos), el mismo ejemplo anterior tendra la siguiente representacin:

Como se mencion previamente para los atributos cuyo tipo de dato son de referencia no se separan espacios en memoria, es decir, para atributos de tipo Pared, Techo y String. En vez de eso, se definen apuntadores a referencias de objetos de dichos tipos.

Simplemente por facilidad y para no complejizar innecesariamente las grficas, a lo largo de

este libro se obviar la definicin de objetos para los tipos de datos de referencia String, es decir, que de ahora en adelante se presentarn los diagramas de la siguiente forma.

1. TPICOS BSICOS

12


Simplemente para hacer claridad en este ltimo punto, la estructura en memoria para el objeto

de la clase Casa nunca es como se muestra en el siguiente grfico.

La definicin de clase hace referencia a dos puntos: primero, la estructura y segundo, el comportamiento. La definicin de la estructura de los objetos de una clase se consigue a travs del establecimiento de sus atributos.

1.5. instAnciAcinEs conveniente introducir en estos momentos la instruccin que posibilita la instanciacin de una clase, de tal manera que se pueda crear un nuevo objeto para el almacenamiento de valores en sus atributos. En Java, para crear un nuevo objeto es necesario utilizar el comando new, seguido del nombre de la clase que se desea instanciar4; entonces para crear un nuevo empleado se utiliza la siguiente instruccin

new Empleado();

4 Cuando se llegue al concepto de mtodo constructor se redefine esta afirmacin. Por ahora, el objetivo es mantener la explicacin lo ms simple posible.

13

Con esta instruccin Java separa un espacio en memoria con la estructura definida para la clase Empleado (es decir, debe haber un espacio cedula para almacenar la cdula del empleado, un espacio apellido para almacenar el apellido del empleado, etc.).

La pregunta que debe surgir en estos momentos es, si con la instruccin new Empleado() se separa espacio en memoria para crear un objeto de la clase Empleado, con qu valores inician los atributos de este nuevo objeto? La respuesta, Java inicializa los valores de los atributos con valores por defecto de la siguiente manera:

Para atributos cuyo tipo sea de referencia, el valor por defecto es null; es decir, la referencia no apunta a ningn objeto.

Para atributos cuyo tipo sea un tipo de dato primitivo, el valor depende del tipo de dato: si es un valor numrico (byte, short, int, long, float y double), su valor inicial es 0; para tipo boolean, el valor inicial es falso (false), y, para tipo char, el valor inicial es \u0000, que corresponde al primer carcter que puede ser representado.

Es decir, despus de ejecutar la instruccin new Empleado(); se crea un objeto de la siguiente manera:

Luego de haber instanciado la clase, puede surgir la siguiente pregunta: cmo se le asignan valores a los atributos del objeto (para poder cambiar los valores por defecto con los que se inicializa)? Como el objeto se crea en un espacio de la memoria, es necesario obtener la referencia a esa posicin en memoria y para poder hacerlo se define una variable, a la que se le asigna dicha posicin en memoria. Se requiere modificar la anterior instruccin por las siguientes:

Empleado elEmpleado;elEmpleado = new Empleado();

O se puede simplificar en una sola instruccin:

Empleado elEmpleado = new Empleado();

1. TPICOS BSICOS

14


El entendimiento de esta definicin suele causar problemas a algunos programadores. La siguiente idea puede ayudar a clarificar la situacin; al trabajar en cualquier lenguaje de programacin a la hora de definir una variable se emplea una instruccin semejante a int a = 50, es decir, primero se define el tipo de dato, luego el nombre de la variable y posteriormente su valor. Si se analiza con detenimiento esta ltima instruccin y se compara con la de creacin de una instancia de Empleado, se obtiene lo siguiente:

Aqu se mencionan los siguientes puntos:

La primera parte de la definicin indica el tipo de dato de la variable (que puede ser un tipo de dato primitivo o de referencia). Esta parte cobra gran importancia al trabajar el tpico de herencia.

La segunda parte de la definicin corresponde al nombre que identificar a la variable. Para la primera definicin, el nombre de la variable es elEmpleado; para la segunda, simplemente el carcter a.

La tercera parte de la definicin especifica el valor que le ser asignado a la variable.

Es importante considerar que aunque se ha intentado realizar una comparacin de ambas instrucciones, por definir variables de tipo de datos distintos, la manipulacin interna que hace el lenguaje de programacin de estas variables es tambin distinto. Recuerde que en la primera instruccin la variable elEmpleado corresponde a una referencia de una posicin en memoria, mientras que la segunda variable efectivamente guarda el valor que se le asigna.

Una vez se tiene una referencia a un objeto (a travs de la definicin de una variable), es posible consultar o modificar el valor de cualquiera de sus atributos. Para hacer cualquiera de estas dos operaciones basta con generar una instruccin donde se especifique la referencia al objeto y al atributo del objeto que se desea manipular; la delimitacin entre ambos se logra empleando el carcter punto (.); por ejemplo, suponiendo que la referencia a un objeto de la clase Empleado se llame elEmpleado,

Se puede cambiar el valor del atributo horasTrabajadas empleando la siguiente instruccin: elEmpleado.horasTrabajadas = 1.5;

Se puede cambiar el valor del atributo sueldoXHora empleando la siguiente instruccin: elEmpleado.sueldoXHora = 100;

Se puede consultar el valor del atributo cdula empleando la siguiente instruccin: elEmpleado.cedula

15

un eJemplo ampliado sobre la instanCiaCin

Considere el siguiente cdigo:

Empleado elEmpleado = new Empleado();elEmpleado.cedula = 12345;elEmpleado.apellido = Prez;elEmpleado.nombre = Pedro;elEmpleado.sueldoXHora = 50;elEmpleado.horasTrabajadas = 20;

Empleado otroEmpleado = new Empleado();otroEmpleado.cedula = 98765;otroEmpleado.apellido = Snchez;otroEmpleado.nombre = Mara;otroEmpleado.sueldoXHora = 120;otroEmpleado.horasTrabajadas = 10;

Despus de ejecutar este cdigo en Java se obtiene una configuracin en memoria similar a la

siguiente:

La anterior grfica debe entenderse de la siguiente manera: existen dos variables de tipo

Empleado que referencian a objetos de la clase Empleado; la primera referencia tiene el nombre de elEmpleado y apunta a un objeto cuyo valor para el atributo cedula es 12345; la segunda referencia tiene el nombre de otroEmpleado y apunta a un objeto cuyo valor para el atributo cedula es 98765. Es recomendable tener pendiente que los valores para los atributos de un objeto (por lo menos de la manera en que han sido definidos hasta el momento) son

independientes de los valores que pueda tener cualquier otro objeto.

1. TPICOS BSICOS

16


sobre el operador lgiCo de ComparaCin y su funCionamiento sobre las variables de tipo primitivo y de referenCia

El lector perspicaz debe estarse preguntando lo siguiente, si los valores de los atributos de un objeto son totalmente independientes de los valores de los atributos de otros objetos de la misma clase, qu evita que se puedan crear dos objetos con exactamente los mismos valores para sus atributos? La respuesta a este cuestionamiento es: nada. Considere el siguiente cdigo:

Empleado elEmpleado = new Empleado();elEmpleado.cedula = 12345;elEmpleado.apellido = Prez;elEmpleado.nombre = Pedro;elEmpleado.sueldoXHora = 50;elEmpleado.horasTrabajadas = 20;

Empleado otroEmpleado = new Empleado();otroEmpleado.cedula = 12345;otroEmpleado.apellido = Prez;otroEmpleado.nombre = Pedro;otroEmpleado.sueldoXHora = 50;otroEmpleado.horasTrabajadas = 20;

En memoria se obtendra la siguiente configuracin:

Es conveniente analizar el comportamiento de las variables al trabajar con el operador lgico de comparacin que provee Java (este operador se denota empleando el smbolo del doble igual == )

17

Cul sera el resultado de ejecutar la siguiente instruccin?

elEmpleado == otroEmpleado

Aunque parezca ilgico, la respuesta de esta instruccin es el valor lgico de falso (false). La explicacin de esta respuesta es simple: si elEmpleado y otroEmpleado son referencias a objetos, la anterior instruccin no compara los valores que componen a los objetos sino las posiciones en memoria donde se encuentran, como son dos objetos distintos, son dos posiciones en memoria distintas.

Desde este punto de vista, cul sera el resultado de ejecutar la siguiente instruccin?

elEmpleado.horasTrabajadas == otroEmpleado.horasTrabajadas

El error ms comn que cometen los programadores que apenas estn conociendo la teora de la programacin orientada a objetos en Java es responder que la instruccin arrojara como resultado el valor lgico falso (false). En este caso, la respuesta es el valor verdadero (true). El porqu de esta respuesta es tambin sencillo: en esta ltima instruccin no se estn comparando referencias sino tipos primitivos, y como los tipos primitivos almacenan el valor, esta instruccin s est comparando los valores de ambas variables.

Como se mencion en el apartado sobre la definicin y manipulacin de los tipos de datos primitivos y los de referencia es realmente importante tener claridad sobre los tipos de datos y sobre la manipulacin que realiza Java sobre ellos.

Un ltimo interrogante que puede surgirle a un programador perspicaz en estos momentos es, cmo comparar dos objetos basndose en su contenido? Aunque despus se analizar ms

ampliamente esta situacin, por lo pronto es conveniente mencionar que para realizar dicho tipo de comparacin es necesario cotejar uno a uno los valores correspondientes de todos los atributos de los objetos.

1. TPICOS BSICOS

18


sobre la reutilizaCin de las variables de referenCia

Analcese el siguiente cdigo:

Empleado e1 = new Empleado();e1.cedula = 12345;e1.apellido = Prez;e1.nombre = Pedro;e1.sueldoXHora = 50;e1.horasTrabajadas = 20;

Empleado e2 = null;Empleado e3 = new Empleado();e2=e1;e3=e1;

Despus de ejecutadas las anteriores instrucciones en memoria, se obtendra la siguiente configuracin:

Dos puntos para mencionar en esta situacin: Existen en memoria tres referencias: e1, e2 y e3. Todas tres apuntan al mismo objeto.

Si empleando la referencia e1 se modifica el valor del atributo horasTrabajadas, ese nuevo valor tambin podr ser consultado empleando cualquiera de las restantes referencias.

En la grfica aparece un objeto Empleado con valores por defecto; cuando un objeto se queda sin ningn tipo de referencia para ser manipulado, un elemento especial de Java, el recolector de basura, lo elimina automticamente.

19

sobre la instanCiaCin y utilizaCin de arrays

En Java, un array es un objeto que representa un conjunto finito y ordenado de elementos

homogneos. En el apartado donde se presenta la codificacin en Java del algoritmo para el clculo de la nmina empleando programacin estructurada se encuentran algunos ejemplos de definiciones de arrays. Se pueden definir arrays de tipos de datos primitivos y de referencia;

los valores con que se inicializan cada una de las posiciones del array siguen las mismas pautas establecidas para la inicializacin de los valores de los atributos explicadas en la seccin de la instanciacin.

La manipulacin de un array de un tipo de dato primitivo en Java es anloga a la manipulacin que hace cualquier otro lenguaje de programacin. Por otro lado, el entendimiento de la manipulacin de arrays de tipo de datos de referencia generalmente causa problemas a los programadores que apenas comienzan a aprender Java y la programacin orientada a objetos. Es conveniente tener presente lo siguiente:

Un array (sin importar el tipo de dato del que es definido) es un objeto que representa un conjunto finito, por ello, al momento de crearlo es necesario especificar la cantidad

de elementos que van a ser parte de este conjunto (este valor debe ser especificado

explcitamente). Resulta til pensar en un array de un tipo de dato de referencia como una referencia a

referencias, es decir, en un apuntador de memoria en donde se registran referencias a otras posiciones en memoria.

Analice el cdigo que se presenta a continuacin:


Empleado e2 = new Empleado();e2.cedula = 98765;e2.apellido = Snchez;e2.nombre = Mara;e2.sueldoXHora = 120;e2.horasTrabajadas = 10;

1. TPICOS BSICOS

20


Empleado[] conjunto = new Empleado[10];conjunto[0] = e1;conjunto[1] = e2;conjunto[2] = e1;

Despus de ejecutarse el anterior cdigo, la memoria queda de la siguiente manera:

Cabe anotar que al instanciar un array de tipo de datos de referencia todas las posiciones del array se inicializan en el valor de null (como ocurre con los atributos)El error ms comn entre los programadores cuando empiezan a conocer el mundo de Java es imaginarse que despus de ejecutar el anterior cdigo el estado de la memoria es similar al que se muestra a continuacin:

21

La clave para comprender esta situacin se encuentra en tener claro que la instruccin new Empleado[10] no instancia diez objetos de la clase Empleado, sino que define que el array almacenar hasta un mximo de diez objetos. Considerando esta situacin, a lo largo del cdigo solo se instancian dos objetos Empleado; por consiguiente, solo deben existir en memoria dos objetos Empleado, y un objeto del tipo array de objetos Empleado.

1. TPICOS BSICOS

22


1.6. mtOdO

primera aproximaCin a la apliCaCin del ClCulo de la nmina mediante programaCin orientada a obJetos

Con los temas cubiertos hasta el momento es posible codificar un primer prototipo para la

aplicacin. Se emplear una lnea para dividir el cdigo de las distintas clases que se presentan.

El primer componente a codificar corresponde a la clase Empleado (se emplear la codificacin presentada anteriormente).


import java.io.BufferedReader;import java.io.InputStreamReader;

class Nomina{ public static void main(String[] args) throws Exception{ int numeroEmpleados; Empleado[] losEmpleados = new Empleado[50]; String cedula, apellido, nombre; double horas, sueldo; double total = 0; BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ); System.out.print(Digite numero de empleados: ); numeroEmpleados = Integer.valueOf(br.readLine()).intValue(); for(int i=0;i

23

nombre = br.readLine(); System.out.print(Digite num de horas trabajadas del empleado: ); horas = Double.valueOf(br.readLine()).doubleValue(); System.out.print(Digite sueldo por hora del empleado: ); sueldo = Double.valueOf(br.readLine()).doubleValue();

Empleado unEmpleado = new Empleado(); unEmpleado.cedula = cedula; unEmpleado.apellido = apellido; unEmpleado.nombre = nombre; unEmpleado.horasTrabajadas = horas; unEmpleado.sueldoXHora = sueldo;

losEmpleados[i]=unEmpleado; }

for (int i=0;i

24


aproximaCin alternativa de la apliCaCin del ClCulo de la nmina mediante programaCin orientada a obJetos

La aplicacin presentada en el anterior apartado inicialmente indaga la cantidad de empleados que posee la empresa y luego va preguntando la informacin puntual de cada uno de ellos. Se

podra definir una aplicacin alternativa que funcione a travs de un men. En este se podran

definir como opciones el ingreso de un nuevo empleado en la nmina de la empresa, calcular

la nmina total y, finalmente, abandonar la aplicacin. El siguiente cdigo en Java representa

esta ltima situacin (se reutiliza la definicin de la clase Empleado aunque no es necesario volverla a codificar):



class Nomina2{ public static void main(String[] args) throws Exception{ int numeroEmpleados=0, opcionMenu=0; Empleado[] losEmpleados = new Empleado[50]; String cedula, apellido, nombre; double horas, sueldo; double total = 0; BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) );

while(opcionMenu!=3){

System.out.println(Menu de opciones); System.out.println(1- Adicionar Empleado); System.out.println(2- Calcular nmina total); System.out.println(3- Salir); System.out.print(Escoja opcin: );

25

opcionMenu = Integer.valueOf(br.readLine()).intValue();

if (opcionMenu==1){

System.out.print(\nDigite la cedula del empleado: ); cedula = br.readLine(); System.out.print(Digite el apellido del empleado: ); apellido = br.readLine(); System.out.print(Digite el nombre del empleado: ); nombre = br.readLine(); System.out.print(Digite num de horas trabajadas: ); horas = Double.valueOf(br.readLine()).doubleValue(); System.out.print(Digite sueldo por hora del empleado: ); sueldo = Double.valueOf(br.readLine()).doubleValue();

Empleado unEmpleado = new Empleado(); unEmpleado.cedula = cedula; unEmpleado.apellido = apellido; unEmpleado.nombre = nombre; unEmpleado.horasTrabajadas = horas; unEmpleado.sueldoXHora = sueldo;

losEmpleados[numeroEmpleados]=unEmpleado; numeroEmpleados++;

} else if (opcionMenu==2){

for (int i=0;i

26


orientada a objetos). En caso de ser necesario calcular cunto se le debe pagar a un empleado bastara con multiplicar el nmero de horas trabajadas por el sueldo que devenga por hora; previendo que el uso de esta operacin puede que sea necesaria utilizarla en posteriores ocasiones, sera conveniente incluirla como parte de una funcin (muchos en este momento pueden estar pensando en no definir ninguna funcin debido a la simplicidad del clculo; sin embargo, se debe considerar que la frmula del sueldo mensual de un empleado podra complejizarse al tener en cuenta la serie de aportes parafiscales como pensin, salud, retencin en la fuente, entre otros ). Pero dnde definir la funcin? Se manejan las siguientes alternativas:

Como la clase Empleado puede que sea reutilizada en varias aplicaciones, sera necesario definir dicha funcin en cada una de ellas; sin embargo, esta no sera una muy buena alternativa, pues se estara replicando el cdigo en muchos lados, y, adems, representara un serio problema en caso de necesitarse la realizacin de una modificacin en la frmula del clculo del sueldo del empleado.

Crear una librera independiente de funciones e incluirla all. Esta librera podra abarcar esta funcin y cualquier otra que aparezca en el desarrollo de la aplicacin.

La mejor alternativa correspondera definirla dentro de la propia clase; de todas formas qu mejor librera a incluirse que la propia clase que genera la necesidad.

En Java desaparecen los conceptos de subrutinas, procedimientos o funciones (que existen dentro del paradigma de programacin procedimental) y se reemplazan por la nocin de mtodo (sin embargo, el comportamiento y la forma de trabajo son anlogos al de las subrutinas). La idea principal es la de ubicar los mtodos junto con los datos sobre los que operan (en este caso, ubicar el mtodo que posibilite el clculo del salario mensual de un empleado junto con los datos del empleado).

Definicin de mtodo

Abstraccin de una accin, servicio, comportamiento o tarea que puede ser realizado por un objeto. Generalmente, un mtodo manipula la informacin registrada en los atributos a travs de una o ms instrucciones.

La definicin de un mtodo en Java requiere bsicamente especificar:

El tipo de dato que retornar como resultado el mtodo. Este tipo de dato puede corresponder a un tipo de dato primitivo, a cualquier tipo de dato de referencia, o en caso de no retornar ningn valor debe especificarse el valor de void.

El nombre del mtodo. La comunidad de programadores de Java maneja una convencin de nombramiento para los mtodos, que establece que el nombre del mtodo debe escribirse en minsculas. Si el nombre de un mtodo est compuesto por varias palabras; se unen las letras de todas las palabras (sin usar ningn carcter

27

especial adicional) y se colocan en maysculas las primeras letras de cada palabra, a excepcin de la primera letra del nombre del mtodo (por ejemplo, calcularSalario).

Un parntesis de apertura y un parntesis de cierre (()), y en caso de requerirse dentro del juego de parntesis, la definicin del conjunto de parmetros que necesita el mtodo para su funcionamiento.

Aadiendo la definicin del mtodo que posibilite el clculo del salario del empleado, la clase Empleado quedara de la siguiente manera:

class Empleado{ String cedula; String apellido; String nombre; double horasTrabajadas; double sueldoXHora;

double calcularSalario(){ return horasTrabajadas * sueldoXHora; }}

En pocas palabras, la definicin del mtodo calcularSalario indica que se debe multiplicar el valor que se tenga en los atributos horasTrabajadas y sueldoXHora, y retornar el resultado.

Para invocar un mtodo se requiere una instruccin donde se especifique la referencia al objeto y al mtodo dentro de ese objeto; la delimitacin entre ambos se logra empleando el carcter punto (.); por ejemplo, suponiendo que la referencia a un objeto de la clase Empleado se llame elEmpleado, se puede invocar el mtodo calcularSalario a travs de la siguiente instruccin: elEmpleado.calcularSalario();

Teniendo en cuenta el siguiente cdigo:


Empleado e2 = new Empleado();e2.cedula = 98765;e2.apellido = Snchez;e2.nombre = Mara;e2.sueldoXHora = 10;e2.horasTrabajadas = 120;

El resultado de ejecutar la instruccin e1.calcularSalario() sera 1000, mientras que la ejecucin de e2.calcularSalario() dara como resultado 1200. Lo anterior simplemente

1. TPICOS BSICOS

28


corrobora que el resultado de la invocacin del mtodo calcularSalario depende de los valores de los atributos del objeto al que se hace referencia.

sobre los parmetros en los mtodos

Determinar qu parmetros deben definirse como parte de un mtodo es una de las situaciones

que causan problemas para los programadores novatos en la programacin orientada a objetos. Por ejemplo, para el caso de la definicin del mtodo calcularSalario, muchos preguntaran por qu no se incluyen como parmetros el valor de las horas trabajadas y el sueldo por hora del empleado.

Supngase por un momento que la definicin del mtodo se ha alterado para reflejar dicho

cambio, por consiguiente el cdigo de la clase Empleado quedara de la siguiente manera:


double calcularSalario(double horasTrabajadas, double sueldoXHora){ return horasTrabajadas * sueldoXHora; }}

Suponga, adems, que se tiene el siguiente cdigo:


29

La instruccin para invocar el mtodo calcularSalario para el objeto e1 sera:

e1.calcularSalario(20,50);

El lector perspicaz debe estar notando que en esta instruccin existe algo extrao. El siguiente grfico ilustra la situacin.

Lo extrao de la situacin corresponde a que a travs de los parmetros se est suministrando informacin que el objeto ya conoce y almacena. Esta instruccin no tiene sentido alguno. El escenario sera el mismo si se ejecutase la siguiente instruccin:

e1.calcularSalario(e1.horasTrabajadas, e1.sueldoXHora);

Cuando se present la definicin de clase, se haca referencia a que esta describe la estructura y comportamiento comn de un conjunto de objetos. La descripcin de la estructura se alcanza a travs de la definicin de los atributos; y la descripcin del comportamiento se alcanza a travs de la definicin de los mtodos.

1.6.1. Mtodo constructorHasta el momento la forma presentada para posibilitar la creacin de un objeto corresponde al empleo de la instruccin new seguida del nombre de la clase; para la asignacin de los valores a los atributos se requieren instrucciones posteriores. Si se analiza el cdigo de las instanciaciones efectuadas hasta el momento se podr notar la cantidad de cdigo que se requiere; se podra pensar en definir un mtodo para facilitar dicho proceso. Dentro de la programacin orientada a objetos ese mtodo recibe el nombre de mtodo constructor.

1. TPICOS BSICOS

30


Definicin de mtodo constructor

Mtodo especial que crea un objeto de la clase y que puede emplearse para especificar aquellas tareas que deban realizarse en el momento de la creacin como, por ejemplo, la inicializacin de los valores de los atributos.

El mtodo constructor es un mtodo especial, y su definicin vara ligeramente del resto. Las particularidades son:

Un mtodo constructor no puede tener definido un tipo de dato de retorno cuando ni siquiera el valor de void es vlido.

El nombre del mtodo debe ser el mismo nombre de la clase (debe coincidir exactamente con el nombre cuidando hasta el uso de letras maysculas y minsculas).

sobre el mbito de las variables y la palabra reservada this

Con los lineamientos que se tienen hasta el momento el cdigo de la clase Empleado quedara de la siguiente forma:


Empleado(String pcedula, String papellido, String pnombre, double phorasTrabajadas, double psueldoXHora){ cedula = pcedula; apellido = papellido; nombre = pnombre; sueldoXHora = psueldoXHora; horasTrabajadas = phorasTrabajadas; } double calcularSalario(){ return horasTrabajadas * sueldoXHora; }}

31

Del anterior cdigo hay varios puntos por analizar:

La cantidad de parmetros definidos es la misma que el nmero de atributos de la clase. Esta situacin se presenta porque para crear un nuevo objeto empleado es necesario que se suministre informacin para cada uno de los atributos. Sin embargo,

no debe seguirse esto como una regla general, porque hay escenarios donde el nmero de parmetros puede diferir del nmero de atributos.

En el apartado sobre los parmetros en los mtodos se estuvo analizando una situacin especial, que no se presenta con los parmetros del mtodo constructor porque, a diferencia del ejemplo all presentado en este caso el objeto no conoce de antemano la informacin del empleado

Para evitar que se presente una confusin con los nombres de los parmetros del mtodo constructor y de los atributos de la clase, se ha optado por anteponerle la letra p al nombre del parmetro.

El cdigo del mtodo constructor se encarga de asignar a cada uno de los atributos del objeto los valores que se suministran en los parmetros correspondientes (es decir, al atributo cedula se le asigna el valor que se recibe en el parmetro pcedula, etc.).

En Java tambin existe la nocin de variable de mbito local y de mbito global, por consiguiente, nada evita que la definicin del mtodo constructor de Empleado tenga la siguiente signatura:

Empleado(String cedula, String apellido, String nombre,double horasTrabajadas, double sueldoXHora)

El problema que se presentara con la ltima definicin del constructor de la clase Empleado es

que tanto los parmetros como los atributos tienen los mismos nombres; por ende, instrucciones

como las que se muestran a continuacin, adems de triviales, son ambiguas e intiles.

cedula = cedula;apellido = apellido;nombre = nombre;sueldoXHora = sueldoXHora;horasTrabajadas = horasTrabajadas;

Qu podran significar las anteriores instrucciones? Habra cuatro posibilidades:

Asgnese al parmetro el valor que tiene el parmetro. Esto carece de sentido porque dicho valor ya se encuentra asignado.

Asgnese al atributo el valor que tiene el atributo. Esto carece de sentido porque uno de los objetivos de un mtodo constructor es inicializar el valor de los atributos del objeto; entonces, la instruccin no est alterando dicho valor.

1. TPICOS BSICOS

32


Asgnese al parmetro el valor del atributo. Tambin carece de sentido porque se estn reemplazando los valores suministrados para instanciar al objeto por los valores por defecto con los que se inicializ la instancia.

Asgnese al atributo el valor suministrado en el parmetro. Esta instruccin si tiene sentido y es la que se busca darle a entender al lenguaje de programacin.

Es conveniente detenerse en este punto para explicar esta situacin con ms detalle. Dentro del paradigma procedimental una variable global2 es aquella que est declarada para el programa o algoritmo principal, del que dependen todos los subprogramas. En otras palabras, es una variable que puede ser usada por cualquier procedimiento. Si se piensa que dentro de una

clase un atributo puede ser utilizado en cualquiera de los mtodos que se definan al interior

de la clase entonces puede asemejarse el concepto de variable global al de atributo (solo bajo la consideracin presentada anteriormente de variable global pero nicamente para la clase). Por su parte, una variable local3 es aquella que est declarada y definida dentro de un subprograma. Con esta definicin se puede decir que cualquier parmetro declarado para un

mtodo, o cualquier variable definida dentro de un mtodo, cae dentro de la definicin de una

variable local.

Considrese el siguiente cdigo de ejemplo:

class Ejemplo{ int a=10; void metodo(){ int a = 20; System.out.println(a); }}

En este ejemplo se define una clase de nombre Ejemplo, que posee un nico atributo de nombre a que se inicializa en el valor de 10, y, adems, posee un mtodo donde se define una variable a que se inicializa con un valor de 20. Hay que comenzar diciendo que por el anlisis previo efectuado sobre las variables de mbito global y local, este ejemplo es totalmente vlido. El interrogante sera, cul es el valor que se mostrar por pantalla en caso de invocar la ejecucin de metodo. La respuesta es 20, y la razn es porque el mtodo cuando necesita trabajar con la variable a primero busca dentro de las definiciones de variables locales que tenga; si encuentra, una trabaja con ella; de lo contrario, trabaja con la definicin global (exactamente as ocurre

dentro del manejo de variables en el paradigma procedimental).

33

Volviendo al caso que inici este anlisis, ya se mencion que para la siguiente definicin del

mtodo constructor de la clase Empleado

Empleado(String cedula, String apellido, String nombre, double horasTrabajadas, double sueldoXHora){

cedula = cedula; apellido = apellido; nombre = nombre; sueldoXHora = sueldoXHora; horasTrabajadas = horasTrabajadas;}

Existan cuatro alternativas de ejecucin, pero despus de conocer cmo es el comportamiento con el mbito de las variables, se pueden descartar tres de las posibilidades; queda nicamente

la alternativa mencionada donde la instruccin ocasionara la asignacin al parmetro del mismo valor que ya tiene (que correspondera a una instruccin trivial).

La solucin a este asunto se encuentra evitando la trivialidad en el cdigo del constructor de la clase Empleado, y cuando se especifica que la accin a ejecutar es la de asignarla al atributo el valor que se recibe en el parmetro. Existe en Java una palabra reservada cuyo significado

ayuda a eliminar la trivialidad; esta palabra es this.

this es una propiedad que tienen todos los objetos en Java y a travs de ella un objeto puede obtener su propia referencia en memoria (su propia posicin). Para ejemplificar esta situacin,

considere el siguiente cdigo:

Empleado e1 = new Empleado();Empleado e2 = new Empleado();

Suponga que el espacio de memoria que se reserva para el primer objeto (e1) tiene la direccin 16f0472 y que el segundo objeto (e2) tiene la direccin 18d107f; si al interior de cualquier mtodo en el objeto (e1) se hace referencia a this se obtendr la direccin 16f0472, y si al interior de cualquier mtodo en el objeto e2 se hace referencia a this se obtendr la direccin 18d107f.

Cmo ayuda this a especificar dentro del constructor que se le asignen a los atributos los valores que se pasan en los parmetros? Si dentro de cualquier mtodo se emplea la instruccin

conformada por la auto referencia this y el nombre del atributo (delimitndose uno del otro con el carcter punto .) se le indica al programa que no debe acceder a la variable local, sino

1. TPICOS BSICOS

34


al atributo en mencin. Por consiguiente, las instrucciones dentro del constructor de Empleado debieran definirse de la siguiente manera:

this.cedula = cedula;this.apellido = apellido;this.nombre = nombre;this.sueldoXHora = sueldoXHora;this.horasTrabajadas = horasTrabajadas;

Tomando en cuenta lo presentado anteriormente (y en especial lo analizado en el apartado sobre el mbito de las variables y la palabra reservada this), el cdigo de la clase Empleado queda de la siguiente manera:


Empleado(String cedula, String apellido, String nombre, double horasTrabajadas, double sueldoXHora){ this.cedula = cedula; this.apellido = apellido; this.nombre = nombre; this.sueldoXHora = sueldoXHora; this.horasTrabajadas = horasTrabajadas; }


Con esta nueva definicin de la clase se simplifica la instanciacin de objetos, pues se pasa de tener que escribir el siguiente cdigo:


35

a simplemente la siguiente instruccin:

Empleado e1 = new Empleado(12345, Prez, Pedro, 20, 50);

Al trabajar con mtodos constructores los siguientes puntos deben ser tenidos en cuenta:

Es conveniente que el mtodo constructor inicialice los valores para todos los atributos.

Una clase puede tener definido ms de un mtodo constructor. Existen varias restricciones que deben cumplirse, pero este tema ser abordado en un captulo posterior.

Por la forma en que se han presentado los ejemplos de las clases empleadas hasta el momento, puede pensarse que dichas estas clases carecan de un mtodo constructor; sin embargo, la situacin real es totalmente opuesta. El lenguaje de programacin Java cuando encuentra una clase que no tiene definido explcitamente un constructor genera de forma automtica un constructor por defecto. Este constructor (que no se le presenta al programador) tiene la particularidad de no tener ningn parmetro definido y, adems, lo nico que hace es inicializar los atributos con sus valores por defecto (estos valores fueron analizados en la seccin donde se habla de la instanciacin). Si una clase tiene definido por lo menos un constructor, Java no generar de forma automtica el constructor por defecto.

En la seccin donde se habla de la instanciacin se mencion que se debe utilizar el comando new seguido por el nombre de la clase; esta definicin no es del todo correcta, en realidad para instanciar una clase se debe utilizar el comando new seguido de uno de los posibles constructores de la clase. El lector perspicaz seguramente habr notado que la clase Empleado que se utiliz para dicho ejemplo no tena constructor y, por ende, Java generaba el constructor por defecto; era ese constructor el que se utilizaba en aquel entonces.

El lector con un alto nivel de suspicacia debe estarse formulando la siguiente pregunta: si String es un tipo de dato de referencia por qu no es necesario utilizar su constructor para crear objetos de este tipo (corrobore esta situacin analizando todos los ejemplos presentados hasta el momento donde se haya requerido un nuevo objeto de la clase String). La clase String es una clase excepcional en Java, es la nica que permite instanciar nuevos objetos simplemente definiendo el texto de la cadena de caracteres a instanciar dentro de comillas5. Tambin se pueden instanciar objetos de esta clase empleando cualquiera de los constructores que esta provee.

El funcionamiento y la manipulacin de un mtodo constructor lo hacen un mtodo atpico pues, a diferencia de los otros mtodos definidos en los ejemplos que se han presentado hasta el momento, este no requiere la referencia a una instancia para ser invocado. Analcese lo siguiente: para invocar el mtodo calcularSalario de la clase Empleado, primero debe tenerse un objeto para luego s invocar la instruccin; en cambio, para invocar la instruccin new Empleado() no es necesaria la referencia.

5 En realidad en Java no es lo mismo instanciar la clase String empleando uno de sus constructores o empleando el con-structor especial; pero esto corresponde a una nocin mucho ms profunda de la que se desea presentar en este libro

1. TPICOS BSICOS

36


segunda aproximaCin a la apliCaCin del ClCulo de la nmina mediante programaCin orientada a obJetos

Con los temas cubiertos hasta el momento es posible codificar un segundo prototipo para

la aplicacin. El primer componente a codificar corresponde a la clase Empleado. El cdigo

que aparece en negrilla resalta las modificaciones efectuadas con respecto a la anterior

aproximacin.





class Nomina{ public static void main(String[] args) throws Exception{ int numeroEmpleados; Empleado[] losEmpleados = new Empleado[50]; String cedula, apellido, nombre;

37

double horas, sueldo; double total = 0; BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ); System.out.print(Digite numero de empleados: ); numeroEmpleados = Integer.valueOf(br.readLine()).intValue(); for(int i=0;i

38


sobre la utilizaCin de paquetes

Con los temas tratados hasta el momento es evidente que no debe permitirse la definicin

de dos clases con el mismo nombre, pues esto podra causarle problemas al sistema a la hora de la instanciacin. Entonces, cmo se podra garantizar que dos programadores cualquiera ubicados en dos lugares del mundo no coincidan en el nombre de una clase.

El lenguaje de programacin Java a travs de la definicin de paquetes4 brinda una forma de organizar clases que se encuentren relacionadas. Un paquete es un espacio de nombres, cuyo concepto es igual al de una carpeta dentro de un sistema de archivos. Java permite definir

paquetes dentro de paquetes (igual que se pueden definir carpetas dentro de carpetas) y definir

dentro de ellos clases. De esta manera s pueden existir clases con el mismo nombre siempre y cuando pertenezcan a distintos paquetes.

Para definir que una clase pertenece a un paquete especfico, se debe incluir la siguiente

instruccin como la primera lnea en el archivo donde se define la clase

package nombredelpaquete;

Por convencin en Java los nombres de los paquetes se encuentran escritos siempre en minsculas. En caso de querer asignar la clase a un subpaquete de un determinado paquete, los nombres de los paquetes deben separarse empleando el carcter punto . (esto implica que dentro de la definicin del nombre de un paquete no puede utilizarse dicho carcter). Por

ejemplo:

package nombredelpaquete.nombredelsubpaquete;

Cuando en la definicin de una determinada clase se necesite la funcionalidad de otra que se

encuentra definida dentro de un paquete, bastar con declarar explcitamente la importacin

de la clase en mencin, lo cual se logra a travs de la siguiente instruccin:

import nombredelpaquete.nombredelsubpaquete.nombredelaclase;

De esta manera se importa la definicin de la clase dentro de la clase. Si lo que se desea es

importar todas las definiciones de clases de dicho paquete, esto bien puede conseguirse a

travs de la siguiente instruccin:

import nombredelpaquete.nombredelsubpaquete.*;

39

Existe una alternativa que evita el tener que declarar la instruccin de importacin de la clase, basta incluir dicha informacin a la hora de la declaracin de la variable; por ejemplo, si se

desea definir una referencia del tipo de dato de los ejemplos presentados hasta el momento en

este apartado, se debe colocar la siguiente instruccin:

nombredelpaquete.nombredelsubpaquete.nombredelaclase a = new nombredelpaquete.nombredelsubpaquete.nombredelaclase();

En el ejemplo anterior a corresponde al nombre de la variable a definir.

1.7. encApsulAmientOMuchas de las crticas que recibe el paradigma de programacin procedimental van dirigidas a la poca proteccin que se brinda a los datos que utilizan las aplicaciones. El porqu de esta afirmacin se explica a continuacin. Considere la siguiente grfica:

El esquema anterior corresponde al esquema general que presenta cualquier aplicacin desarrollada bajo el paradigma procedimental. Dicho esquema debe entenderse de la siguiente manera: toda aplicacin est compuesta por un conjunto de variables globales junto con un conjunto de subrutinas (incluida la subrutina principal) en las que se definen, en caso de ser necesarios, un conjunto de variables locales para dichas subrutinas.

El problema principal de la programacin procedimental radica en la poca proteccin que se brinda a las variables globales porque cualquier subrutina puede alterar sus valores indiscriminadamente. Imagine el siguiente escenario: dos variables globales enteras de nombre v1 y v2; dentro de la aplicacin, para la primera de ella solo tiene sentido la asignacin de valores positivos, pero la segunda puede tomar cualquier valor. Por un simple descuido (de digitacin) dentro de una subrutina se le asigna el valor de -2 a la variable v1 cuando en realidad dicho valor deba ser asignado a v2; el resultado de ese descuido pone a mal funcionar todas las subrutinas que trabajan con el valor de v1 y, por ende, a toda la aplicacin.

En el apartado sobre el mbito de las variables y la palabra reservada this se analiz cmo es el comportamiento del mbito de las variables cuando se trabaja bajo el paradigma de orientacin a objetos. El siguiente grfico ejemplifica, a grosso modo, cmo es la situacin.

1. TPICOS BSICOS

40


El anterior esquema debe entenderse de la siguiente manera: las aplicaciones orientadas a objetos estn conformadas por un conjunto de clases; estas poseen atributos (que se pueden entender como variables globales pero solo al interior de las clases) y mtodos en los que se definen, en caso de ser necesarias, variables locales. Aunque el enfoque de ambos paradigmas vara considerablemente; los dos presentan el mismo problema: permitir que desde cualquier clase se altere el valor del atributo de otro objeto (como, por ejemplo, cuando se accede y modifica el valor de la cdula sobre un objeto empleado).

El encapsulamiento ayuda a corregir este problema.

Definicin de encapsulamiento

El encapsulamiento hace referencia a ocultar los detalles de implementacin internos del objeto a los dems. Esta propiedad permite asegurar que el contenido de la informacin de un objeto se encuentra seguro del mundo exterior.

La forma de implementar el encapsulamiento en una clase se logra a travs del uso de niveles de visibilidad (tambin conocidos como modificadores de acceso).

Con los temas vistos hasta el momento se pueden definir dos niveles de visibilidad6:

6 Adems del nivel de visibilidad por defecto (el que se ha manejado en los ejemplos hasta el momento), existe otro que se presentar en la seccin correspondiente a la herencia.

41

Definicin de nivel de visibilidad pblico

Cuando se aplica a un atributo o mtodo de una clase se especifica que dicha informacin o accin es visible; se puede acceder a aquel tanto en el interior como en el exterior de la clase donde se encuentra definido. Cuando se aplica a una clase5, se especifica esta clase puede ser utilizada desde cualquier clase de cualquier paquete

El siguiente diagrama puede facilitar la comprensin del nivel de visibilidad pblico. Las flechas que aparecen en l representan la utilizacin del elemento sealado por la punta de la flecha y el otro extremo (de la flecha), el sitio de donde es invocado el elemento. Suponga que todos los atributos y mtodos de la clase Clase1 son pblicos, por ende, ellos pueden ser accedidos tanto al interior (cuando un mtodo de Clase1 invoca otro mtodo de la misma clase, o cuando un mtodo de Clase1 accede a un atributo de la propia clase) como al exterior de la clase donde se encuentra definido (cuando un mtodo de Clase2 accede a un atributo de Clase1, o cuando un mtodo de Clase3 invoca un mtodo de Clase1).

Para especificar un atributo o mtodo pblico en Java se le debe anteponer a su definicin la palabra reservada public. Para especificar que una clase es pblica se debe anteponer la palabra reservada public a la definicin de la clase.

1. TPICOS BSICOS

42


Definicin de nivel de visibilidad privado

Cuando se aplica a un atributo o mtodo de una clase se especifica que dicha informacin o accin solo puede ser visible (accesible) al interior de la clase donde se encuentra definido.

El siguiente diagrama puede facilitar la comprensin del nivel de visibilidad privado. Las flechas que aparecen en l representan la utilizacin del elemento sealado por la punta de la flecha y el otro extremo (de la flecha), el sitio de donde es invocado el elemento. Para este caso suponga que todos los atributos y mtodos de Clase1 son privados, por ende, se puede acceder a ellos solo desde el interior de la propia clase (cuando un mtodo de Clase1 invoca otro mtodo de la misma clase, o cuando un mtodo de Clase1 accede a un atributo de la propia clase).

Para especificar un atributo o mtodo privado en Java se le debe anteponer a su definicin la palabra reservada private. No es posible definir una clase con un nivel de visibilidad privado.

43

sobre los niveles de visibilidad pbliCo y privado

Considrese el siguiente cdigo:

class Empleado{ private String cedula; private String apellido; private String nombre; private double horasTrabajadas; private double sueldoXHora;


double calcularSalario(){ return horasTrabajadas * sueldoXHora; }

}

Al definir todos los atributos de la clase Empleado como privados se especifica que a estos solo se les puede acceder o modificar mediante instrucciones ubicadas en el interior de algn mtodo

de la clase; ninguna clase externa podr acceder ni mucho menos modificar dichos valores.

Por ejemplo, las siguientes instrucciones ubicadas en cualquier clase distinta a Empleado no solamente no se podran ejecutar, sino que ni siquiera podran ser compiladas por Java. El error en compilacin se marcara en la segunda instruccin porque no se puede modificar el

valor de un atributo privado. Si los atributos fueran pblicos, no se presentara ningn tipo de

error de compilacin.

Empleado e1 = new Empleado(12345, Prez, Pedro, 20, 50);e1.apellido = Prez Sosa;

Por qu la implementacin de niveles de visibilidad en el cdigo corrigen los problemas de proteccin de los datos? El problema a corregir radica en que en la programacin estructurada cualquier subrutina puede alterar el valor de cualquier variable global. desde el paradigma de orientacin a objetos y con la utilizacin del encapsulamiento se ha restringido esa situacin porque ahora con la utilizacin del modificador de acceso privado solo pueden alterar los valores de los atributos los mtodos ubicados al interior de la clase. Esto aumenta el control sobre los datos.

1. TPICOS BSICOS

44


En este punto, cualquier programador debe estarse preguntando, cmo se puede alterar el valor del atributo de algn objeto en caso de ser absolutamente requerido? A travs de mtodos pblicos codificados especialmente para poder obtener el valor de un atributo (este tipo de mtodos se conocen como mtodos accesores) y mtodos pblicos que permitan modificar el valor del atributo (este tipo de mtodos se conocen como mtodos modificadores).

Aunque no es una imposicin del lenguaje Java, como recomendacin general el nombre del mtodo accesor para un atributo debe formarse anteponiendo la palabra get (del ingls obtener) al nombre del atributo; de la misma forma, el nombre mtodo modificador debe formarse anteponiendo la palabra set (del ingls establecer) al nombre del atributo.

El cdigo de la clase Empleado queda de la siguiente forma:

public class Empleado{ private String cedula; private String apellido; private String nombre; private double horasTrabajadas; private double sueldoXHora;

public Empleado(String cedula, String apellido, String nombre, double horasTrabajadas, double sueldoXHora){ this.cedula = cedula; this.apellido = apellido; this.nombre = nombre; this.sueldoXHora = sueldoXHora; this.horasTrabajadas = horasTrabajadas; }

public double calcularSalario(){ return horasTrabajadas * sueldoXHora; }

public String getCedula(){ return cedula; } public void setCedula(String cedula){ this.cedula = cedula; }

public String getApellido(){ return apellido; } public void setApellido(String apellido){ this.apellido = apellido; }

public String getNombre(){ return nombre; } public void setNombre(String nombre){ this.nombre = nombre; }

45

public double getHorasTrabajadas(){ return horasTrabajadas; } public void setHorasTrabajadas(double horas ){ this.horasTrabajadas = horas; }

public double getSueldoXHora(){ return sueldoXHora; } public void setSueldoXHora(double sueldo ){ this.sueldoXHora = sueldo; }

}

Puntos convenientes a resaltar en el anterior cdigo:

Note que la clase Empleado se ha especificado como pblica.

Note que tanto el mtodo constructor de la clase como el mtodo para calcular el salario del empleado se encuentran definidos con un nivel de visibilidad pblico, puesto que se desea que cualquier otra clase pueda invocar este servicio que exhibe el objeto.

Para cada atributo de la clase se ha definido un mtodo accesor y uno modificador. No es obligatorio que un atributo tenga ambos mtodos.

Un programador atento debe estar pensando lo siguiente, si uno de los objetivos de los niveles de visibilidad era no permitir que desde clases externas se alteren los valores de los atributos de una clase, al definir mtodos accesores y modificadores se pierde todo lo que se haba avanzado; y ahora se regresa a una posicin an peor que la inicial en la medida en que es necesario escribir una mayor cantidad de cdigo7 (pues las instrucciones que se requieren para codificar estos mtodos). Aun cuando aparentemente se ha terminado en un estado peor al inicial, la realidad es distinta.

Antes (en la programacin estructurada), cualquiera podra alterar los valores de las variables globales. Ahora tambin es posible alterar el valor de los atributos a travs de mtodos modificadores; pero la diferencia es que se pueden escoger cules mtodos modificadores exhibir una clase a las restantes clases (piense que ahora si no se desea cambiar el valor de la cdula de un empleado, simplemente no se define como pblico el mtodo setCedula).

Antes, a una variable global entera definida para aceptar nicamente valores positivos poda asignrsele un valor fuera del rango en cualquier subrutina de la aplicacin. Ahora tambin es posible hacerlo; la diferencia es que hoy la realizacin de dicha asignacin se ejecuta invocando un mtodo en el cual puede ubicarse

7 La mayora de los entornos de desarrollo para Java brindan la capacidad de generar de forma automtica (con unos cuantos clics) los mtodos accesores y modificadores para los atributos de una clase.

1. TPICOS BSICOS

46


el cdigo de validacin para dicho atributo. Por ejemplo, el cdigo para el mtodo setHorasTrabajadas puede definirse de la siguiente manera, de tal forma que el objeto no pueda aceptar valores negativos para dicho atributo:

public void setHorasTrabajadas(double horas){ if (horas>=0) this.horasTrabajadas=horas; else this.horasTrabajadas=0;}

terCera aproximaCin a la apliCaCin del ClCulo de la nmina mediante programaCin orientada a obJetos

Para esta tercera aproximacin los nicos cambios profundos a implementar se encuentran en la clase Empleado. La clase Nomina permanece casi que sin alteraciones.

El cdigo que aparece en negrilla resalta las modificaciones efectuadas con respecto a la anterior

aproximacin.

public class Empleado{ private String cedula; private String apellido; private String nombre; private double horasTrabajadas; private double sueldoXHora; public Empleado(String cedula, String apellido, String nombre, double horasTrabajadas, double sueldoXHora){ setCedula(cedula); setApellido(apellido); setNombre(nombre); setSueldoXHora(sueldoXHora); setHorasTrabajadas(horasTrabajadas); } public double calcularSalario(){ return horasTrabajadas * sueldoXHora; }

public String getCedula(){ return cedula; } private void setCedula(String cedula){ if (cedula!=null) this.cedula = cedula; else this.cedula = ; } public String getApellido(){ return apellido; }

47

public void setApellido(String apellido){ if (apellido!=null) this.apellido = apellido; else this.apellido=; }

public String getNombre(){ return nombre; } public void setNombre(String nombre){ if (nombre!=null) this.nombre = nombre; else this.nombre=; }

public double getHorasTrabajadas(){ return horasTrabajadas; } public void setHorasTrabajadas(double horas ){ if (horas>=0) this.horasTrabajadas = horas; else this.horasTrabajadas = 0; }

public double getSueldoXHora(){ return sueldoXHora; } public void setSueldoXHora(double sueldo ){ if (sueldo>=0) this.sueldoXHora = sueldo; else this.sueldoXHora = 0; }

}


public class Nomina{ public static void main(String[] args) throws Exception{ int numeroEmpleados; Empleado[] losEmpleados = new Empleado[50]; String cedula, apellido, nombre; double horas, sueldo; double total = 0;

BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ); System.out.print(Digite numero de empleados: ); numeroEmpleados = Integer.valueOf(br.readLine()).intValue();

for(int i=0;i

48


System.out.print(Digite el nombre del empleado: ); nombre = br.readLine(); System.out.print(Digite num de horas trabajadas del empleado: ); horas = Double.valueOf(br.readLine()).doubleValue(); System.out.print(Digite sueldo por hora del empleado: ); sueldo = Double.valueOf(br.readLine()).doubleValue();

Empleado unEmpleado = new Empleado(cedula, apellido, nombre, horas, sueldo);

losEmpleados[i]=unEmpleado; }

for (int i=0;i

49

Es conveniente notar que la clase Empleado simplemente describe la estructura y el comportamiento de un conjunto de empleados. Dentro de esta descripcin es importante resaltar que no se encuentra definido cdigo para leer o escribir informacin

por pantalla. Note que todo el cdigo de lectura y de escritura de los datos reside en la clase Nomina. Realizar este tipo de desacoplamiento corresponde a una muy buena prctica de programacin porque incita y facilita la reutilizacin de cdigo. Imagnese que existiera otra aplicacin que requiera de trabajar con los objetos de la clase Empleado, pero a diferencia de la aplicacin de la nmina, esta ltima trabaja en un ambiente grfico con ventanas y botones; se podra trabajar con la clase Empleado si estuviera codificada de tal manera que los datos se leen de pantalla preguntndoselos

al usuario? La respuesta es un rotundo no.

La idea detrs del encapsulamiento es realmente sencilla, lo que se busca es proteger el estado interno de los atributos. Como consecuencia, cuando otra clase requiera trabajar con una clase encapsulada, lo har sin acoplarse a su estructura interna. Al no hacerlo, los cambios dentro de la estructura de la clase encapsulada no repercutirn en cambios en el cdigo de las clases que la utilicen.

Analice cmo se encuentran definidas las cosas en el mundo real. Ponga por ejemplo una habitacin que cuente con iluminacin en una casa cualquiera. Qu tan complejo es realizar el cambio para que la iluminacin de la habitacin deje de ser incandescente y se vuelva fluorescente? En realidad lo que se requiere es muy poco, simplemente basta con cambiar el tipo de foco que alumbra a la habitacin. En el mundo de la programacin, hay ocasiones en que la realizacin de un cambio que se cree sencillo requerira, en trminos del ejemplo anterior: quitar la antigua base del foco, reventar el techo, reventar la pared, quitar los alambres que conducen la corriente, instalar nuevos alambres, repellar la pared, arreglar el techo, instalar la nueva base y, finalmente, instalar el nuevo tipo de foco.

El cambio del tipo de foco en una habitacin no es una actividad traumtica en la vida real porque de antemano los fabricantes se ponen de acuerdo en los servicios que exhibir el foco y en lo que se necesita para su funcionamiento. De all en adelante los fabricantes crean focos a partir de las convenciones establecidas (dimetro, profundidad, tipo de material, conductibilidad del material, etc.). As debiera ser tambin el mundo del desarrollo de software, los fabricantes de componentes (software) debieran especificar detalladamente como son los servicios que ha de exhibir un elemento (se puede pensar en los servicios a exhibir cmo en los mtodos pblicos de la clase). Los clientes (otros programas o aplicaciones) se acoplan a los servicios y no a cmo es que encuentran implementados. Esta ltima idea corresponde a, quizs, la mejor de las prcticas que se pueden tener en el mundo de la programacin.

Analice el caso de ejemplo que se presenta a continuacin. Imagine que Java carece de un componente que le permita manipular elementos de tipo fecha y que se encuentra interesado en la construccin de tal tipo de componente.

1. TPICOS BSICOS

50


Los servicios que debe prestar el componente son:

El de conocer el valor del nmero correspondiente al mes de la fecha.

El de conocer el nombre del mes correspondiente a la fecha.

El de obtener la fecha en el siguiente formato dd/mm/aaa

programación orientada a objetos en java

Documents