Métodos
Los métodos son utilizados para definir un grupo de instrucciones que son separadas y que definen un comportamiento, que requieren en algunos casos de valores para su proceso.
Un método es algo muy utilizado en la programación de Java y en POO representa las conductas de los objetos que se traten.
El método nos ayuda a definir un cambio en algún objeto y es importante que entendamos como funciona un método ya definido y como utilizarlo al hacer alguna aplicación o un applet, pues el método es clave, pieza principal de la programación orientada a objetos.
Los métodos pueden ser de un tipo específico como int, double, String, Cuenta, etc. o simplemente no tener algún tipo como void.
Cuando un método es void, este método no se espera que regrese algún valor a la aplicación que utilizó algún objeto que tenga esé método como parte de la definición de la clase.
Si un método es definido como int, entonces debe utilizar la instrucción return y el valor int calculado.
Algunos ejemplos son:
public int obtenValor() {
return valor; // donde valor es de tipo entero
}
public double obtenSaldo() {
return saldo; // donde saldo es de tipo double
}
public void cambiaSaldo(saldo) {
this.saldo = saldo; //igualando la variable de la clase al parámetro
}
Paso de Parámetros
Al utilizar un parámetro, la manera en la que el método utiliza el parámetro que le es pasado es la que define que tipo de paso de parámetro es.
Por valor
Cuando a un método se le pasa un parámetro de algún tipo de datos primitivo (char, int, double, etc), lo que hace el método internamente en memoria es sacar una copia del valor que se está pasando para no afectar a la variable que ha sido enviada a través del método, por ejemplo:
Si tenemos la variable int x en un método llamado uno y este método llama al método dos y este método dos también tiene una variable x, el método dos saca una copia de x, y aunque es bautizada con el mismo nombre, se respeta el valor de x en el método uno. Veamos el caso:
public void uno() {
int x = 10;
dos(x);
System.out.println(“ x en uno = “ + x);
}
public void dos (int x) {
x = x + 2;
System.out.println(“ x en dos = “ + x);
}
Al ejecutar estos métodos en alguna aplicación, observaríamos como se despliega:
x en dos = 12
x en uno = 10
Mientras que la x que se mando a dos se copio con el valor 10 y se le sumaron 2, dando 12, la x que esta en uno sigue valiendo 10, porque se saca una copia del valor para mandarse a dos.
Paso de parámetros por Referencia
Esto se verá en la siguiente unidad temática, donde se explica Clases y Objetos.
Utilicemos en este momento la definición de la clase Punto, esta clase nos ayuda a visualizar el comportamiento de cualquier objeto Punto, con sus diferentes tipos de métodos:
public class Punto {
private int x; // variable para la coordenada en x
private int y; // variable para la coordenada en y
public Punto() { // método para construir un objeto sin parámetros
x = 0;
y = 0;
}
// método para construir un objeto con parámetros
public Punto(int x, int y) {
this.x = x;
this.y = y;
}
public int obtenX() { // método que te dá el valor de la coordenada x
return x;
}
public int obtenY() { // método que te dá el valor de la coordenada y
return y;
}
// método que sirve para cambiar el valor //de la coordenada x
public void cambiaX(int x) {
this.x = x; // this se utiliza porque se esta utilizando (x)
// como parámetro y como
// variable de instancia y esto es para que no se confunda
}
// método que te sirve para cambiar el valor de la coordenada y
public void cambiaY(int y) {
this.y = y; // this se utiliza porque se esta utilizando (y)
//como parámetro y como
// variable de instancia y esto es para que no se confunda Java
}
}
Variables de Instancia
Esta clase utiliza primero que nada las variables de la clase, llamadas variables de instancia, ya que con cada objeto que se cree de la clase, se crea una instancia de estas variables para cada objeto diferente. Estas variables se deben definir como privadas.
Métodos Constructores
Posteriormente revisamos que tiene dos métodos que se llaman igual a la clase, pero que no manejan algún tipo, es decir o int, o double o String, etc., solamente se dice son públicos. A estos métodos se les llama constructores y son los que se utilizan cuando se crea un objeto de la clase. Es muy importante que un método constructor tenga definido internamente la asignación para cada una de las variables de instancia.
Métodos de Acceso. los Getter
Posteriormente se definen los métodos obtenVariable(), llamados métodos de acceso, es decir se define un método por cada variable de instancia (de acuerdo al tipo de cada variable), esto es algo que nos permite obtener el valor de cada variable, ya que las variables han sido definidas como privadas, para que alguien de otra clase no las pueda modificar directamente.
Métodos Modificadores. Los Setter
Luego se definen los métodos modificadores cambiaVariable(), de tipo void (ya que no regresan valor), estos métodos deben cambiar el valor de cada variable, y solo a través de ellos es que se deben cambiar los valores de las variables de instancia, ya que ellas son privadas.
Por convención de Java , inclusive dentro de la misma clase, si se desea cambiar el valor de una variable deberán utilizarse para esto los métodos modificadores y de acceso, es decir, aunque sabemos que si queremos incrementar la x en 1, podemos hacer:
x++;
O
x = x + 1;
Para respetar las normas de convención de código Java, debemos utilizar los métodos modificadores y de acceso, de tal manera que quedara de la siguiente manera:
cambiaX ( obtenX() + 1 );
Aunque se ve mucho más largo o mucho más difícil de entender, tiene su porque, el porque es debido a que si algo se debe de hacer cuando se modifique el valor de x o cuando se obtenga el valor de x, por ejemplo, entonces se hace en el método modificar o el método de acceso, correspondientemente, de esta manera no se pierde el control del comportamiento de las variables de instancia del objeto y es así como se mantiene la intregridad, este es un muy buen hábito de programación.
*** Solo los métodos constructores y métodos de acceso o métodos de modificación pueden acceder directamente las variables de instancia de la clase.***
Esta clase queremos que contenga un método que nos sirva para dibujar un punto en la coordenada (x,y), entonces crearemos un nuevo método llamado dibujaPunto(), el cual requerirá un elemento gráfico como el que hasta ahora hemos utilizado con un applet
public void paint(Graphics g)
Si el método dibujaPunto() de la clase Punto no recibe como parámetro el objeto gráfico de la clase Graphics, no habrá manera que pueda dibujar el punto.
Veamos como quedaría ahora nuestra clase Punto modificada:
public class Punto {
private int x; // variable para la coordenada en x
private int y; // variable para la coordenada en y
public Punto() { // método para construir un objeto sin parámetros
x = 0;
y = 0;
}
// método para construir un objeto con parámetros
public Punto(int x, int y) {
this.x = x;
this.y = y;
}
public int obtenX() { // método que te dá el valor de la coordenada x
return x;
}
public int obtenY() { // método que te dá el valor de la coordenada y
return y;
}
// método que sirve para cambiar el valor //de la coordenada x
public void cambiaX(int x) {
this.x = x; // this se utiliza porque se esta utilizando (x)
// como parámetro y como
// variable de instancia y esto es para que no se confunda
}
// método que te sirve para cambiar el valor de la coordenada y
public void cambiaY(int y) {
this.y = y; // this se utiliza porque se esta utilizando (y)
//como parámetro y como
// variable de instancia y esto es para que no se confunda Java
}
public void dibujaPunto(Graphics g) {
g.fillOval(obtenX() , obtenY(), 5, 5);
}
}
Es importante aquí hacer notar que para dibujar el Punto, se utiliza el método obtenX() y el método obtenY(), aun y cuando se pudieran utilizar directamente “x” y “y”, directamente, se usan los métodos, ya que esto representa una norma de la programación orientada a objetos.
Esta clase se utiliza creando un objeto de ella dentro de un applet y haciendo uso de sus métodos:
import java.awt.*;
import java.applet.*;
import java.awt.event.*;
// <applet width="200" height="200" code="AppletMetodos1"></applet>
public class AppletMetodos1 extends Applet implements ActionListener {
Label l1, l2, l3,l4;
TextField t1, t2, t3,t4;
Button b;
Punto p;
public AppletMetodos1() {
l1 = new Label("X");
t1 = new TextField(4);
l2 = new Label("Y");
t2 = new TextField(4);
b = new Button("DIBUJA PUNTO");
add(l1);
add(t1);
add(l2);
add(t2);
add(b);
b. addActionListener(this);
}
public void paint(Graphics g) {
p.dibujaPunto(g);
}
public void actionPerformed(ActionEvent ae) {
int x = Integer.parseInt(t1.getText()); // lee el valor TextField t1 y se lo pasa a x
int y = Integer.parseInt(t2.getText()); // lee el valor TextField t2 y se lo pasa a y
p = new Punto(x, y);
repaint();
}
}
Nota: Para ejecutar el ejemplo en Consola / Terminal
1) Hay que crear dos archivos.
Uno llamado Punto.java, con el código de la clase Punto, (añadiendole import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.applet.*;
import java.awt.event.*;
delante de la definición de clase)
y otro llamado archivo con el nombre AppletMetodos1.java , y se le pone el código del Applet
2) Se compilan:
javac Punto.java
y
javac AppletMetodos1.java
3) Y se ejecuta con comando:
AppletViewer AppletMetodos1.java
En el se puede observar un punto grande en la coordenada 100, 100, ahora hicimos este punto grande con el método fillOval y mandándole un diámetro de mas de un pixel para que se viera la diferencia.
Al utilizar un método, o al llamar (invocar) un método, nosotros le podemos pasar valores al método y a su vez, el método puede utilizar aquellos valores que han sido definidos en forma global, por ejemplo, nosotros en la clase Punto, dentro del método paint(), podemos utilizar x, o y, ya que ambas son variables de instancia definidas arriba de todos los métodos, por lo tanto todos los métodos pueden utilizar el valor de x o el valor de y.
Por otro lado la clase Punto no es un applet y no tiene la capacidad de dibujar en un elemento gráfico por si solo, por eso desde el método paint() del applet, le pasamos al método paint de la clase Punto, el parámetro gráfico g, y de esa manera dentro del método paint() de la clase Punto es como este método puede dibujar.
Es importante también que notes que en la clase Punto al introducir el método paint(), se hizo el import java.awt.*; ya que ahora que se dibuja, se requiere utilizar el método fillRect() el cual pertenece a los elementos de la clase Graphics que está dentro de ese paquete.
Un método es definido como void cuando no requiere regresar un valor a quien lo llamó. En caso de requerir regresar un valor este puede ser de los mismos tipos que las variables definidas al principio:
Tipo de método
|
descripción formato/tamaño
|
Byte
|
entero de tamaño byte 8-bits a complementos a dos
|
Short
|
entero corto 16-bits a complementos a dos
|
int
|
entero 32-bits a complementos a dos
|
long
|
entero grande 64-bits a complementos a dos
|
float
|
punto flotante de precision sencilla 32-bits IEEE 754
|
double
|
punto flotante de doble precision 64-bits IEEE 754
|
char
|
un solo caracter caracter de 16-bits de tipo Unicode
|
boolean
|
valor boleano (true o false) true o false
|
NombreClase
|
Alguna clase existente representará un objeto de alguna clase conocida
|
Las variables y objetos definidos y creados dentro de un método se consideran locales al método y solo pueden ser utilizados dentro de él. Si al llamar a otro método se quiere que el método llamado utilice alguna variable o algún objeto, dicho método debe de tomarlo a través de un parámetro para tal efecto.
Es muy importante que los métodos se llamen con el número exacto de variables y/o objetos definidos como parámetros, asi como el tipo correspondiente de cada uno de ellos.
Posibles Problemas con la creación de un objeto.
Es muy común que cuando se ejecute el método paint() en el applet anterior, el applet no haya creado aun el objeto punto p, de tal manera que no hay objeto creado para dibujar, una modificación a este applet para que funcionara sin problemas es revisar que el objeto p haya sido creado para poder dibujarlo, entonces el método recomendado para paint() sería:
public void paint(Graphics g) {
if (p != null) {
p.dibujaPunto(g);
}
}
Esto entonces revisaría primero si el objeto no es null (o sea que ya tiene algo adentro) y entonces se dibujaría el punto p, utilizando para ello el método dibujaPunto de la clase Punto.
No hay comentarios:
Publicar un comentario