Pensar en objetos (II)

1. REPASO

A ntes de continuar con nuestro curso de programación

orientada a objetos, vamos a repasar lo que aprendió en la
pasada lección.

Recuerde la diferencia entre las clases y los objetos. Una clase

actúa como plantilla o modelo de los objetos, mientras que estos
últimos son los que realmente puede utilizar en el código.

Recuerde que los objetos constan de dos tipos de componentes: las

propiedades, que describen detalladamente los objetos y los métodos,
que describen su comportamiento.

Tanto las propiedades como los métodos se escriben en el interior

de la clase, pero se utilizan cuando trabajamos con los objetos.

También recuerde la existencia de un método especial: el

constructor. Este método sirve para crear objetos y es el lugar idóneo
para iniciar el valor de las propiedades de los objetos.

Finalmente, recuerde la sintaxis que debe utilizar para acceder a

una propiedad de un objeto: nombre_objeto.nombre_propiedad.

En el caso del constructor, el objeto al que se hace referencia es el

propio objeto que se está creando. Para ello, se utiliza la palabra clave
this.

2. CREAR OBJETOS

H asta ahora sólo hemos escrito código Java para describir las
características que presenta la clase Coche. Es el momento
de aprender a crear objetos.

Una vez creados los objetos, podrá utilizar sus métodos e incluso
acceder a sus propiedades.

Pero antes, es necesario comentar que podemos escribir un método

especial en toda clase Java. Este método se llama main y, si existe, es
el punto de entrada a la clase.

Es decir, si usted desea ejecutar su clase como una aplicación,

deberá escribir un método main e indicar en éste las acciones a
realizar.

Copyright © Computer Aided Education, S.A. 1

 Pensar en objetos (II)

public static void main(String[] args)

{

Todo método main tendrá este prototipo. Debe entender que es

un método público (ya veremos qué significa esto), estático y que no
devuelve ningún valor.

Ahora veamos cómo se crean los objetos:

Coche c = new Coche("rojo", 0, 0)

En esta línea se crea un objeto de la clase Coche. Observe cómo

se hace:

- Se indica el tipo o la clase del objeto: Coche.

- Se utiliza una variable de ese tipo: c.
- Se utiliza la palabra clave new para indicar que se está creando
el objeto.
- Se utiliza el constructor de la clase Coche con los, parámetros
oportunos.

En este caso estamos creando el objeto c, que será un coche de

color rojo y situado en la posición (0, 0).

Esta línea podría estar en el interior del método main. Una vez
creado el objeto, podría acceder a sus propiedades y métodos de la
forma conocida:

public static void main(String[] args)

{
Coche c = new Coche("rojo", 0, 0);
System.out.println("La velocidad del coche " + c.color
+ " es de " + c.velocidad);
c.acelerar();
System.out.println("Tras acelerar, la velocidad del
coche es de " + c.velocidad);
c.frenar();
System.out.println("Tras frenar, la velocidad del
coche es de " + c.velocidad);
System.out.println("El número de ruedas del coche es "
+ c.numRuedas);
}

2
 Pensar en objetos (II)

Observe que la sintaxis para acceder a una propiedad o a un

método es la misma. El compilador distingue entre propiedades y
métodos según el nombre utilizado.

Así, con la expresión c.velocidad estamos accediendo al valor

de la propiedad velocidad del objeto c; mientras que con c.acelerar()
utilizamos su método acelerar.

En el caso de los métodos siempre incluirá un par de paréntesis,

aunque no utilicen parámetros.

Utilizando la línea System.out.println(...) imprimimos en

pantalla una cadena de texto que es justamente la que aparece entre los
paréntesis. Se utiliza el operador + para concatenar dos o más cadenas
de texto.

Por lo tanto, hemos creado el objeto c de la clase Coche. Después,

hemos accedido a alguna de sus propiedades y hemos utilizado alguno
de sus métodos.

Todo esto lo hemos hecho en un método especial de clase, el

método main. Este método sólo es necesario cuando quiere ejecutar la
clase como una aplicación.

3. COMPILAR EL CÓDIGO

U na vez hemos escrito el código del método main, podemos

ejecutar la clase como una aplicación.

Para ello, la clase primero tiene que ser compilada, es decir, indicar
a NetBeans que desea generar el bytecode o código independiente de
la plataforma.

En el menú Build disponemos

de varios comandos que utilizaremos
Si sólo desea
compilar el ar- para compilar nuestro código, pero
chivo en el que principalmente dos de ellos:
está trabajan-
do, elija Com-
pile... ya que  Build Main Project: este comando es el adecuado cuando
el proceso será el proyecto se compone de varios archivos de código fuente
mucho más (clases), ya que compila todos ellos.
rápido que si
se tiene que
compilar todo  Compile "archivo.java": sirve para compilar el archivo .java
el proyecto. en el que está trabajando.
Copyright © Computer Aided Education, S.A. 3
 Pensar en objetos (II)

Finalmente vamos a ejecutar la aplicación para lo que utilizaremos

el comando Run Main Project en el menú Run.NetBeans muestra el
resultado de la ejecución de nuestra aplicación en la ventana Output.

Observe cómo al principio la velocidad del coche rojo es de 0,

después 10 y finalmente vuelve a ser 0. Además, el número de ruedas
de este coche (y de todos) es 4.

Al generar o compilar con éxito

una clase Java, es decir, un
fichero con la extensión .java,
se crea un nuevo archivo con
el mismo nombre pero con la
extensión .class. Esto lo podrá
comprobar en la ventana Files
del entorno de NetBeans.

Es importante recordar que ha

podido ejecutar la clase gracias
a que ésta contenía un método
main.

De ahí que si lo que desea es crear una aplicación Java, lo mejor

es indicarlo desde el principio y elegir el tipo de proyecto Java
Application en el cuadro de diálogo New Project.

Esto creará una clase Java en la que ya se incluye el método

main, además de marcar el proyecto como Main o principal, que es
lo que hemos tenido que hacer para poder ejecutar nuestro pequeño
programa.

Cuando estudiemos los applets, veremos que no hará falta incluir

este método, ya que la clase se ejecutará en el interior de una página
web.

4
 Pensar en objetos (II)

Por lo tanto ya sabemos que el archivo .java es, de código

fuente y puede ser editado, mientras que el archivo .class es
el resultado de la compilación.

Él archivo .class es el que contiene el bytecode y que

posteriormente será interpretado por el entorno de ejecución
JRE.

4. OCULTAR LA INFORMACIÓN

U no de los principios fundamentales de la programación

orientada a objetos es el de la ocultación de la información.

Este principio indica que la estructura interna de una clase debe

quedar oculta y sólo mostrar aquellas partes de la clase que podemos
utilizar. Con un ejemplo se entiende mejor.

Volvamos a pensar en la idea del coche. Si a usted le interesa

acelerar o frenar un coche, ¿para qué quiere saber lo que ocurre en la
maquinaria cuando pisa el acelerador o el freno?

Si más tarde decide poner un sistema antibloqueo de frenos, seguro

que no le gustaría que le cambiaran su forma de frenar. Lo que quiere
es seguir presionando el freno como siempre, independientemente de
que se utilice un sistema diferente del que tenía antes.

La forma de ocultar información en Java se consigue con los

modificadores public, protected y private.

Estos modificadores anteceden al nombre de las clases, de las

propiedades o de los métodos.

Normalmente, las propiedades deben ser privadas, es decir, sólo

accesibles en la propia clase y no fuera de ella.

private String color;

private int posX;
private int posY;
private int velocidad;

Si declara privadas las propiedades, entonces sólo son accesibles

desde el interior de la clase; es decir, los métodos de la clase podrán
utilizarlas, pero no así desde una clase distinta. La forma de permitir
acceder a estas propiedades desde fuera de la clase es a través de los
métodos públicos.

Copyright © Computer Aided Education, S.A. 5

 Pensar en objetos (II)

public void mover(int x, int y)

{
if (x != posX)
posX = x;
if (y != posY)
posY = y;
}

Observe lo que estamos consiguiendo: permitirá que otras partes

de su aplicación puedan mover un objeto Coche sin que estas partes
sepan realmente que están cambiando el valor de las propiedades posX
y posY.

Y es que realmente no lo necesitan saber. Todavía diría más, no

deben conocer ni que existen esas propiedades: simplemente moverán
el coche.

Seguro que se ha dado cuenta de las ventajas que esto conlleva.

Por ejemplo, si más tarde decide que, al mover el coche, tiene que
sonar un pitido, ¿qué tiene que hacer en esta situación?

La respuesta es clara: simplemente modificar el método mover.

Si no aplicara este enfoque, debería buscar todos los lugares del código
donde se ha movido el coche e indicar entonces que también debe sonar
un pitido.

El método main ya utiliza el modificador public. Esto es necesario,

ya que es el punto de entrada a la clase y lo mismo podemos decir del
constructor o constructores de una clase, que normalmente también
tendrán el modificado public, ya que si no fuera así, no se podría crear
objetos desde fuera de la clase.

Si no se especifica un modificador de acceso, como private o

public, los miembros componentes de una clase (propiedades y
métodos) tienen un nivel de acceso de paquete.

Es decir, que son accesibles desde todas las clases definidas en un

mismo paquete, pero no en paquetes diferentes.

En próximas lecciones aprenderá más sobre los paquetes.

Un aspecto que no hemos comentado es que también se puede

establecer el nivel de acceso de las clases.

Podrá definir más de una clase en un mismo archivo, pero sólo

una de ellas podrá ser public. El sentido sería el mismo que
para los componentes miembro de las clases.

6
 Pensar en objetos (II)

Ahora imagínese esta situación: desea cambiar el tipo de datos de

las propiedades posX y posY, de forma que puedan representar valores
decimales.

Siguiendo el principio de ocultación de la información, las

propiedades son privadas, por lo que sólo pueden ser accesibles desde
la propia clase. Por lo tanto, el cambio está limitado a esa clase.

Además se debe seguir la regla de definir dos métodos que permitan

obtener el valor de cada propiedad (lectura) y establecer dicho valor
(escritura). De esta forma, el cambio sería todavía más localizado ya
que sólo tendría que modificar esos dos métodos.

Por ejemplo, se podría utilizar los métodos getVelocidad() o

setVelocidad(valor) para obtener o establecer, respectivamente, la
velocidad de un objeto coche.

Resumiendo podríamos decir que, al utilizar los modificadores de

acceso a los miembros de una clase, está indicando qué servicios puede
ofrecer la clase al código exterior.

Si usted decidiera que es conveniente poder conocer la velocidad

de un objeto Coche desde fuera de la clase, simplemente debería
incorporar un método público que devolviera dicho valor. Como
el método sería de la clase Coche, podría acceder a la propiedad
privada.

5. ENCAPSULAR PROPIEDADES

N etBeans nos facilita seguir fielmente el principio de la

ocultación de la información que hemos estudiado en el
apartado anterior.

Así, mediante el comando Encapsulate fields (Encapsular campo)

del menú Refactor nos genera, automáticamente, un par de métodos
get y set para las propiedades de la clase.

Las técnicas de “refactoring” están pensadas para facilitar la

compresión del código que escribimos y su modificación en un
futuro.

Con la técnica Encapsulate filed, NetBeans establece como

privada la propiedad que le marcamos y crea un método public con el
código necesario para obtener su valor y otro para establecerlo.
Copyright © Computer Aided Education, S.A. 7
 Pensar en objetos (II)

Para utilizar este comando, seleccione la propiedad en el código y

elija el comando correspondiente del menú Refactor o haga lo propio
en su menú contextual.

En este cuadro de diálogo podremos establecer qué métodos

de acceso (get y set) deseamos crear para la propiedad y con qué
modificadores (private, public o protected).

En la lista Field’s Visibility se indica el modificador para la

propiedad y en Accessor’s Visibility, la correspondiente para los
métodos que se crearán.

Una vez comprobamos que todo es correcto, pulsaremos en el

botón Next, con lo que NetBeans nos informa en la ventana Refactoring
de la parte inferior, de los cambios que realizará en el código antes de
llevarlos a cabo.

En la figura anterior vemos que:

8
 Pensar en objetos (II)

 Cambiará el modificador de acceso de la propiedad numRuedas

a private.
 Creará un método público de nombre getNumRuedas para
obtener el valor de dicha propiedad.
 Creará otro método público de nombre setNumRuedas para
modificar el valor de esa propiedad.
 Modificará la línea donde se utiliza la propiedad numRuedas
en el método main para que, en su lugar, se utilice el método
getNumRuedas.

Es decir, que NetBeans hará por nosotros los cambios que

deberíamos realizar para que nuestro código cumpliera fielmente con
el principio de ocultación de la información.

Debe pulsar en el botón Do Refactoring (Realizar Refactoring)

para que se lleve a cabo. De la misma forma deberíamos actuar con el
resto de propiedades de la clase.

En ocasiones, no nos interesará crear un método get o un

método set para una determinada propiedad, por lo que
podremos tener propiedades de sólo lectura o de sólo
escritura.

Las propiedades de sólo lectura disponen de un método

get para obtener su valor, pero no de un método set para
cambiarlo.

Al contrario ocurre con las propiedades de sólo escritura,

que sí que disponen de un método set para modificar su valor,
pero éste no puede ser obtenido o consultado al carecer de
método get.

A continuación se detalla el código completo de la clase Coche

incluyendo estos detalles:
public class Coche {
private static int numRuedas = 4;
private String color;
private int posX;
private int posY;
private int velocidad;
public void mover(int x, int y)
{
if (x != getPosX())
setPosX(x);
if (y != getPosY())
setPosY(y);
}

Copyright © Computer Aided Education, S.A. 9

 Pensar en objetos (II)

public int acelerar()

{
setVelocidad(getVelocidad() + 10);
return getVelocidad();
}

public int frenar()

{
Fíjese que if (getVelocidad() > 10)
como la setVelocidad(getVelocidad() - 10);
propiedad else
numRuedas setVelocidad(0);
es estática, los return getVelocidad();
métodos get- }
NumRuedas y
setNumRuedas
public Coche(String color, int posx, int posy) {
son también
estáticos. this.setColor(color);
this.setPosX(posx);
this.setPosY(posy);
this.setVelocidad(0);
}

public static int getNumRuedas() {

return numRuedas;
}

public static void setNumRuedas(int aNumRuedas) {

numRuedas = aNumRuedas;
}

public String getColor() {

return color;
}

public void setColor(String color) {

this.color = color;
}

public int getPosX() {

return posX;
}

public void setPosX(int posX) {

this.posX = posX;
}

public int getPosY() {

return posY;
}

public void setPosY(int posY) {

this.posY = posY;
}

10
 Pensar en objetos (II)

public int getVelocidad() {

return velocidad;
}

public void setVelocidad(int velocidad) {

this.velocidad = velocidad;
}

public static void main(String[] args)

{
Fíjese que se Coche c = new Coche("rojo", 0, 0);
utiliza el nom-
System.out.println("La velocidad del coche " +
bre de la clase
c.getColor() + " es de " + c.getVelocidad());
a la hora de
llamar al mé- c.acelerar();
todo estático System.out.println("Tras acelerar, la velocidad del
getNumRue- coche es de " + c.getVelocidad());
das en lugar c.frenar();
del nombre del System.out.println("Tras frenar, la velocidad del
objeto. coche es de " + c.getVelocidad());
System.out.println("El número de ruedas del coche
es " + Coche.getNumRuedas());
}
}

Copyright © Computer Aided Education, S.A. 11