PDF de programación - Métodos

Métodos

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:

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.



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()

public void dos (int x)

{

{

int x = 10; dos(x);

x = x + 2;

System.out.println(“ x en uno = “ + x);

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;
}
public Punto(int x, int y) // método para construir un objeto con parámetros
{

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

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

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);
}
El applet ejecutado quedaría:


public void paint(Graphics g)
{
p.dibujaPunto(g);
}

public void actionPerformed(ActionEvent ae)
{
int x = Integer.parseInt(t1.getText());
int y = Integer.parseInt(t1.getText());
p = new Punto(x, y);
rep