Métodos creados por el usuario -- Parte I

Hoy se va a seguir trabajando con el mismo código que se vio en el último ejemplo, el de la pelotita que era movida por el teclado del celular, para mostrar otro concepto de la sintaxis de Java, la creación de métodos definidos por el usuario.

Ya se ha trabajado con muchísimos métodos a lo largo del blog, por ejemplo:

  Clase                    Método       

TextField             getString()               

                            setText()                   

Graphics             drawArc()

                            drawString()
                           drawImage()

GameCanvas      flushGraphics()

Todos absolutamente todos los métodos fueron creados por Sun Microsystem cuando desarrollo java y están agrupados en paquetes de clases a los que se tiene acceso por medio de la instrucción import. Hoy se va hablar de métodos pero de otro tipo, no los creados por Sun, si no, los métodos definidos por el usuario.

Métodos Definidos por el usuario

Un método es como una subrutina o un pequeño segmento de código que en términos generales sirve para dividir o descomponer un problema grande en partes más pequeñas que se invocan o se llaman desde la mima clase o desde otras clase

El siguiente segmento de código muestra el método llamado constructor, que se hizo en el post del ejemplo #20 y en el #19 :

El constructor entre otras cosas, carga las imágenes que se van a usar en el programa y crea un subproceso para el control de la animación, se puede dividir esta tarea, en partes bien definidas que son cargar las imágenes y crear el subproceso, se puede entonces crear un par de métodos que haga eso, pero veamos esto con calma.

public Animacion() {

  super(true);

  g = getGraphics();

  try {

     fondo = Image.createImage("/fondo.jpg");

     pelota = Image.createImage("/pelotita.gif");

  } catch (Exception e) { }

  subproceso = new Thread(this);

  subproceso.start();

}

La sintaxis para crear un método definido por el usuario es en términos generales así:

Identificador_de_acceso    valor_de_regreso    Nombre_del_metodo( parametros ) {

         //Código del método

}

Enseguida se explican las cuatro partes que consta el método

1. Identificador de acceso

El identificador de acceso es algo así como la protección que tiene el método y es que el método creado por el usuario puede invocarse desde la misma clase o desde otras clases, el identificador de acceso nos da ciertos niveles de seguridad, existen varios tipos de identificadores de acceso:

• private

• protected

• public

• package

El lector debe elegir un tipo para usarlo en la definición del método, el método creado debe iniciar con una de esas palabras reservadas de Java, ¿pero cúal usar? Enseguida se da una definición superficial de cada uno de estos niveles de acceso.

a) Private

Este es el nivel de acceso más restringido, un método privado solo se puede invocar o solo se tiene acceso desde la misma clase donde está definido, los métodos privados son digámoslo así secretos para todos menos para la clase donde están ubicados, justo este tipo de acceso es el que se va usar en los métodos que vamos a crear, ¿Por qué? Sencillo porque el programa solo consta de una clase (bueno en realidad son dos clases el MIDlet y la clase que hereda de GameCanvas que es donde está todo el código, por eso digo que solo consta de una clase), así que no necesitamos invocar este método desde otros lados, programas que constan de varias clases si requieren de otro identificador de acceso.

Vamos a tomar la definición de la clase vista anteriormente para ir formando nuestro método, entonces, se debe agregar la palabara private al inicio del método así:

private valor_de_regreso Nombre_del_metodo( parametros ) {

    //Código del método

}

b) Protected

Este nivel de acceso permite invocar el método desde la misma clase o desde las subclases, recuerde una subclase es la que deriva de otra y hereda sus métodos y propiedades, por ejemplo la clase del ejemplo #20 se llama Animación y deriva de la clase GameCanvas, Game Canvas es la clase y Animación es la subclase, esto es el concepto de herencia, que por lo pronto no ahondaremos en este concepto.

c) Public

Este identificador de acceso es el más sencillo y se ha visto ya en varios métodos que se han realizado, por ejemplo la definición del método run del ejemplo #19 es así:

public void run( ) {

    //código del método run

}

Note el identificador de acceso public, como siempre va al inicio del método, este tipo de acceso significa que todas las clases de todos los paquetes de clases tienen acceso al método, un paquete de clases, es un grupo de clases que se relacionan, por ejemplo, Java tiene el paquete de clases llamado Game, en donde está ubicada la clase GameCanvas y otras clases más que se relacionan porque sirven para la programación de juegos para el celular, recuerde los paquetes de clases se agregan al programa en Java usando la palabra import.

d) Package

Este nivel de acceso permite invocar métodos desde cualquier clase que este en el mismo paquete.

2. Valor de Regreso

Este es el segundo punto en la definición del método. Java por fuerza requiere que los métodos regresen un valor a la clase donde se invocan, valor se refiere a algún tipo de dato que se calculo o en el método, el tipo de datos son los ya conocidos, por ejemplo int, boolean, float, double, en el caso que el método creado no regrese ningún valor se coloca la palabra reservada void.

Regresando a nuestro ejemplo, deseamos crear un método para cargar las imágenes y otro para crear un subproceso, las imágenes se cargan con una simple instrucción e igual el subproceso, en otras palabras estos métodos no requieren que se regrese ningún valor, entonces se usa el void como valor de retorno, el método que vamos creando toma la siguiente forma:

private void Nombre_del_metodo( parametros ) {

//Código del método

}

En el siguiente post se hablará de los métodos que regresan valores.

3. Nombre del método

El nombre del método es la tercera parte de la definición del método, este nombre es elegido por el usuario, puede ser cualquiera pero recuerde las reglas básicas: no se vale escribir espacios, no se vale iniciar con un número o carácter alfanumérico, solo se vale el guión bajo.

En nuestro ejemplo el método va a cargar las imágenes, así que como nombre usamos: cargarImagenes entonces el método va quedando así:

private void cargarImagenes( parametros ) {

//Código del método

}

4.- Parámetros

La última parte de la definición del método son los parámetros, estos van después del nombre del método, y deben ir entre paréntesis, los parámetros que en algunos casos no son necesario, sirven como una especie de comunicación entre la clase que los invoca y el método creado por el usuario, en otras palabras, los parámetros son el medio para enviar información desde la clase que los invoca al método creado.

En el método que estamos diseñando no se requiere enviar ninguna información de nada, esto significa que no lleva parámetros por ende, los paréntesis van vacios así:

private void cargarImagenes( ) {

//Código del método

}

Listo la definición del método está terminada, ahora solo va el código necesario para cargar la imagen este código se vio arriba en el constructor de la clase Animación, el método completo y terminado queda así:

private void cargarImagenes( ){

   try {

   fondo = Image.createImage("/fondo.jpg");

   pelota = Image.createImage("/pelotita.gif");

   } catch (Exception e) { }

}

El lugar para colocar este código es en cualquier parte dentro de la clase, no importa donde esté Java lo busca.

También en otro post se mostrarán algunos métodos que si llevan parámetros.

Invocación del método

Para que este método se ejecute se debe mandar llamar o invocar desde alguna parte la clase, en este caso obviamente es desde el constructor, para hacerlo basta con colocar el nombre del método seguido de sus parámetros entre paréntesis, así:

cargarImagenes();

Entonces el constructor ya con la llamada al método queda así:

public Animacion() {

   super(true);

   g = getGraphics();

   cargarImagenes( );

   subproceso = new Thread(this);

   subproceso.start();

}

Eso es todo, cuando el NetBeans encuentre la invocación al método, el flujo de programa cambia, busca el método y ejecuta las instrucciones que ahí se indican, al terminar el método el flujo de programa se regresa a donde se quedo, esto queda más claro con una animación, una animación vale más que mil palabras.

La siguiente animación muestra el método creado junto con el constructor, así como se muestra es como Java ejecuta el método, todo inicia en el constructor, las instrucciones que están en el constructor es lo que se ejecuta primero, note como cambia el flujo de programa cuando se encuentra la instrucción para mandar llamar el método y observe también como al terminar el método el flujo de programa regresa a donde se había quedado.

Método para crear el subproceso

Enseguida se muestra la creación de otro método, el método que se diseñará simplemente crea el subproceso, ya sabemos que todo se inicia con el identificador de acceso, igual que el anterior lo colocamos como “prívate”, luego sigue el tipo de retorno, tampoco en este caso se regresa nada así que se coloca la palabra “void”, luego va el nombre del método, lo llamaremos “crearSubproceso”, luego va entre paréntesis la lista de parámetros, este método no los requiere así que los paréntesis van vacios, con lo anterior fácilmente se crea el método así:

private void crearSubproceso(){

   subproceso = new Thread(this);

   subproceso.start();

}

Para invocar el método, como ya se vio, basta con colocar su nombre así:

crearSubproceso()

Código Completo

El siguiente código muestra el constructor, note donde se ubica la instrucción para mandar llamar los métodos, junto con los dos métodos creados en esta sección, recuerde la ubicación de los métodos no lleva un orden pueden estar primero o después del constructor, Java los busca y los ejecuta, este es el código con los métodos creados por el usuario:

public Animacion() {

   super(true);

   g = getGraphics();

   cargarImagenes();

   crearSubproceso();

}

private void cargarImagenes(){

  try {

    fondo = Image.createImage("/fondo.jpg");

    pelota = Image.createImage("/pelotita.gif");

  } catch (Exception e) { }

}

private void crearSubproceso(){

  subproceso = new Thread(this);

  subproceso.start();

}

Observación final

Enseguida vuelvo a repetir el código para el constructor para el ejemplo #20 tal y como se mostro inicialmente:

public Animacion() {

   super(true);

   g = getGraphics();

   try {

      fondo = Image.createImage("/fondo.jpg");

      pelota = Image.createImage("/pelotita.gif");

   } catch (Exception e) { }

   subproceso = new Thread(this);

   subproceso.start();

}

Compare este constructor con todo el código anterior el de los métodos creados, los dos hacen exactamente lo mismo, crear las imágenes y el subproceso, pareciera que no se ve ventaja alguna, y quizá así es para este caso, pero créanme es altamente recomendable pensar en términos de métodos, en términos de dividir el problema en partes, por decirlo de alguna manera, las partes son los métodos, se anima al lector para que así lo haga y en adelante así se harán los video-tutoriales siguientes, son muchas las ventajas de usarlos, como se verá en un futuro.

Próxima entrada del blog

Este tema fue muy largo y aún así nos quedaron dos temas pendientes:

• Los métodos que regresan valores

• Los métodos con parámetros

Esto se abordara en la próxima entrada, que ojala sea esta misma semana.