9.1.

Métodos:
Las clases constan de dos elementos principales: variables de instancia y métodos, estos son
bloques de código con nombre, tipo de acceso, tipo de retorno y una lista de parámetros.
Todo el código ejecutable en Java se sitúa dentro de un método, el cual consta de dos partes:
cabecera y cuerpo.
Sintaxis:
tipo nombre (lista de parámetros){ // cabecera
// cuerpo del método
}

Si el método no devuelve un valor, su tipo de retorno debe ser void. El nombre del método
puede ser cualquiera distinto de aquellos ya utilizados y no puede ser igual a una palabra
reservada Java.
La lista de parámetros es una secuencia de parejas de identificadores y tipos de datos
separados por comas, los parámetros son variables que reciben el valor de los argumentos
pasados al método cuando este es llamado, si el método no tiene parámetros entonces la
lista estará vacía.

Ejemplo:
public class Saludo{
//otras partes de la clase

void saludoBienvenida(){
System.out.println("¡Hola! ");
System.out.print(" Método llamado saludoBienvenida");
System.out.println(" que contiene tres sentencias ");
}

public static void main(String[]args){

Saludo unObjeto = new Saludo();
unObjeto.saludoBienvenida();
}
}
El programa Saludo declara dos métodos, a continuación de saludoBienvenida() viene un
segundo método llamado main(), este es el primero que se llama cuando le programa
comienza a ejecutarse y contiene las secuencias que crean y utilizan un objeto Saludo.

9.2. Método main():

La ejecución de cualquier programa o aplicación de Java comienza con una llamada al método
main() situado en la clase, no todas las clases necesitan un método main(), solo las que son
el punto de arranque del programa.
El método main() se declara static, ya que es llamado por la maquina virtual en tiempo de
ejecución antes de que se cree cualquier objeto.
Sintaxis:
public static void main(String [] args)
Si no se encuentra ningún método main() el programa no se ejecutara y visualizara el
siguiente mensaje de error:
Exception in thread "main" java.lang.NoSuchMethodError: main

9.3. Retorno de un método (return):

return => Se utiliza para salir o terminar la ejecución del método y devolver el valor
especificado por el tipo de retorno, si el tipo es void la palabra reservada return se utiliza
sola.
Sintaxis:
return;
return valor;
Ejemplo:
int flex(){
int clorExtremo;
// realiza cálculos y almacena resultados en clorExtremo
return clorExtremo;
}

Ejemplo 9.1:
El método calcularArea() de la clase Rectangulo se utiliza para devolver el área de un rectángulo.
public class PruebaRetorno{
public static void main(String ar[]){
Rectangulo r = new Rectangulo(3.0,7.0);
System.out.println(" El área es " + r.calcularArea());
}
}

class Rectangulo{
private double base, altura;

public Rectangulo(double b, double h){

base = b;
altura = h;
}

public double calcularArea(){

return base*altura;
}
}
Al compilarlo, la ejecución crea el objeto r que llama a calcularArea() dentro de println(), da lugar a:
El área es 21.0

9.3.1. Llamada a un método:

Para que los métodos se ejecuten deben ser llamados, la llamada se realiza desde un método
de otra clase o desde uno de la misma clase.
El método llamado recibe el control del programa, se ejecuta desde el principio y cuando
termina, al alcanzar la sentencia return o la llave de cierre (}) si se omite return, el control
del programa vuelve al método llamador.
La llamada a un método desde otro de la misma clase y para el mismo objeto se realiza
escribiendo el nombre y entre paréntesis la lista de argumentos actuales.
Ejemplo:
class Semana{
public void listado(int horas){
int dia;
dia = diaSemana()¡
// ...
}
int diaSemana() {
...
}
}

Semana nueva = new Semana();

nueva.listado(23);
La ejecución del método listado() supone la llamada al método diaSemana() de la misma
clase y para el mismo objeto.

La llamada a un método desde otro objeto se realiza con el nombre del objeto, el selector
punto (.) y el nombre del método con sus argumentos actuales.
Sintaxis:
objeto.nombreMetodo(lista de argumentos actuales);

Hay métodos como el método static que no son de los objetos sino de la clase, la llamada a
uno de estos métodos se hace con el nombre de la clase, el selector punto (.) y el nombre
del método con sus argumentos actuales.
Sintaxis:
nombreClase.nombreMetodo(lista de argumentos actuales);

Ejemplo 9.2:
En la clase Matem se define un método que calcula el factorial de un entero, el cual es static; por consiguiente,
se invoca con el nombre de ésta: Matem.factorial(); la clase principal llama a factorial() para enteros de
1 a 15.
class Matem{
static long factorial (int n){
long p = 1;
for (int i = 2; i<=n; i++)
p *= i;
return p;
}
// ...
}

public class CalculoFact{

public static void main (String[] a){
final int M = 15;
for (int n = 1; i <= M; i++)
System.out.println(n + "! = " + Matem.factorial(n);
}
}

9.4. Acceso a métodos:

No siempre se puede llamar a un método, puede que solo se pueda llamar desde la clase.
Cada método tiene un tipo asociado de control, public, private o protected aunque
puede no especificarse.
 - public: se puede llamar por cualquier código que tenga acceso a la clase main().
- private: solo se puede llamar desde otro método de la clase a la que pertenece.
- protected: se puede llamar desde otro método de la propia clase y por cualquier otro
método de las clases hijas.
- ningún tipo de acceso: el método es accesible a todas las clases contenidas en el
mismo paquete, pero no lo es fuera de ese paquete.

Ejemplo 9.3:
En un paquete se declaran varias clases, tienen métodos con distintos niveles de acceso.
package dolmen;

public class Primera{

private void goliar() {
...
}
public double homero(){
goliar();
}
protected void jureste() {
...
}
String salustio() {
...
}
}

public class Segunda{

public void balsas(){
Primera p = new Primera();
p.goliar(); // error, el método goliar() es privado
p.Salustio(); // correcto, está en el mismo paquete
}
}
// fin del paquete

import dolmen.*;
public class Prueba{
public static void main(String ar[]){
Segunda st = new Segunda(); // crea un objeto
Primera pt = new Primera(); // crea objeto
st.balsas(); // llamada correcta por tener acceso público
pt.homero(); // llamada correcta por tener acceso público
pt.salustio(); // error, el acceso es el paquete dolmen
}
}

9.5. Paso de argumentos a métodos:

Los argumentos se pasan a los métodos por valor, se hace una copia del tipo de dato
primitivo (int, float, etc.) o la referencia al objeto de la clase o array, para dar valores
iniciales a los argumentos de los métodos.
Algunos métodos no necesitan parámetros, aunque la mayoría si, los parámetros permiten
que un método pueda operar sobre una gran variedad de datos o que pueda utilizarse en
situaciones diferentes.
Ejemplo:
int cuadrado(int n){ //cuadrado() devuelve cualquier valor entre paréntesis
return n*n;
}

int x,y;
x = cuadrado(10); // se pasa el valor 10; x es igual a 100
y = cuadrado(15); // se pasa el valor 15; x es igual a 225
y = 5;
x = cuadrado(y); // se pasa el valor de y; x es igual a 25

9.5.1. Paso de parámetros por valor:

Paso por valor significa que cuando se llama al método, este recibe una copia de los valores
de los parámetros, si el método cambia el valor de un parámetro no tiene efecto fuera del
método, solo afecta a este.

Ejemplo 9.4:
El listado de la clase principal PorValor muestra el mecanismo de paso de parámetros por valor; se puede
cambiar la variable del parámetro en el método, pero su modificación no puede salir del método.
class PorValor{
public static void main(String[] a){
int n = 10;
System.out.println("Antes de llamar a demoLocal, n = " + n);
demoLocal(n);
System.out.println("Después de la llamada, n = " + n);
}

static void demoLocal(int valor){

System.out.println("Dentro de demoLocal, valor = " + valor);
valor = 999;
System.out.println("Dentro de demoLocal, valor = " + valor);
}
}
La ejecución muestra la salida:
Antes de llamar a demoLocal, n = 10
Dentro de DemoLocal, valor = 10
Dentro de DemoLocal, valor = 999
Después de la llamada, n = 10
Ejemplo 9.5:
El listado de la clase principal PorValorObjeto muestra cómo se pasa la referencia de un objeto creado y
pueden modificarse sus miembros dato.
class Julian{
String fecha;
int dias;

Julian(){
fecha = "01-Jan-2001";
dias = 1;
}
void mostrar(){
System.out.println("Fecha actual: " + fecha+ "\t Dias = " + dias);
}
// ...
}

// clase principal
class PorValorObjeto{
public static void main(String[] a){
// crea objeto de la clase Julian
Julian jan = new Julian();
// muestra valores actuales
System.out.println("Propiedades del objeto en la creación.");
jan.mostrar();
// llamada a método que modifica el objeto
modifica(jan);
System.out.println("Propiedades del objeto modificado.");
jan.mostrar();
}
static void modifica(Julian obj){
// se modifican las variables instancia de obj
p.fecha = "01-Feb-2001";
p.dias = 32;
}
}
La ejecución muestra la salida:
Propiedades del objeto en la creación.
Fecha actual: 01-Jan-2001 Dias = 1
Propiedades del objeto modificado.
Fecha actual: 01-Feb-2001 Dias = 32

9.5.2. Lista de parámetros:

Se pueden declarar una lista de parámetros en lugar de uno solo, la lista es una secuencia de
ellos separada por comas.
Ejemplo:
double gr1(double a, double b){
return (a*15)-(b*25);
}

gr1(5.40,6.25); //llamada correcta a gr1

gr1(5,6,0.25); //llamada no válida a gr1

9.5.3. Modificador final:

Si se quiere que el valor pasado a la variable no cambie, delante de la declaración al nombre
del parámetro se deberá poner la palabra reservada final.
Ejemplo:
double polinomio2(final double x){
return x*x + x*2 – 5.0;
}
final hace que el valor de x no pueda ser modificado después de inicializado, si final no
esta presente en la declaración, entonces el valor del parámetro se puede modificar dentro
del cuerpo del método, el contexto en que se ejecute el método determina si es aconsejable
poner un parámetro final o no.

9.6. Métodos abstractos:

En el contexto de una jerarquía de clases, específicamente de generalización/especialización,
los métodos abstractos se definen en clases para imponer funcionalidad a las subclases. Estos
métodos se definen por la palabra abstract y no tienen cuerpo.
Ejemplo:
En una clase Figura se definen los métodos abstractos calcular-Area() y perimetro() que
devuelven el área y el perímetro respectivamente, las subclases Circulo y Rectangulo se
pueden definir como subclases de Figura, y como el área de un rectángulo y de un círculo se
calculan utilizando fórmulas matemáticas diferentes, las clases respectivas proporcionarán
sus propias implementaciones de los métodos calcularArea() y perimetro().

Ejemplo 9.6:
El programa PruebaFigura calcula el área y el perímetro de las figuras geométricas Circulo y Rectangulo.
La implementación de las clases y métodos abstractos de la jerarquía cuya superclase es Figura se encuentra
en el paquete figuras.
import figuras.*;

public class PruebaFigura{

public static void main(String ar[]){
Rectangulo r = new Rectangulo(7.0,9.0); // objeto Rectángulo
Circulo c = new Circulo (2.0); // objeto Círculo

System.out.println("El área del rectangulo es " +

r.calcularArea() + "\t el perímetro " + r.perimetro());
System.out.println("El área del círculo es " +
c.calcularArea() + "\t el perímetro " + c.perimetro());
}
}

9.7. Sobrecarga de métodos:

Sobrecarga de métodos => Definir dos o más métodos dentro de la misma clase que
compartan nombre y que las declaraciones de sus parámetros sean diferentes.
En las llamadas a los métodos sobrecargados el compilador determina cual es el método
invocado basándose en el número y tipo de argumentos pasado, los métodos sobrecargados
deben diferir en número y tipo de parámetros.

Ejemplo 9.7:
Se define la clase llamada sobrecarga con cuatro métodos de nombre prueba sobrecargados, diferenciándose
entre ellos por el número/tipo de los parámetros; main() llama a cada uno de ellos.
El método prueba() se sobrecargó cuatro veces; la primera versión no tiene parámetros; la segunda, 1 entero;
la tercera, 2 enteros y la cuarta, 3 de tipo double.
class Sobrecarga{
public void prueba(){
System.out.println(" Método sin argumentos.");
}

// Sobrecarga de prueba() con 1 parámetro tipo int

public void prueba(int x){
System.out.print(" Método con 1 argumento. ");
System.out.println(" x = " + x );
}

// Sobrecarga de prueba() con 2 parámetro tipo int

public void prueba(int x, int y){
System.out.print(" Método con 2 argumentos. ");
System.out.println(" x = " + x + "; y = " + y);
}

// Sobrecarga de prueba() con 3 parámetros

public void prueba(double x, double y, double z){
System.out.print(" Método con 3 argumentos. ");
System.out.println(" x = " + x + "; y = " + y + "; z = " + z);
}
}

// clase con el método main()

class DemoSobrecarga{
public static void main(String []ar){
Sobrecarga objeto = new Sobrecarga();
// llamada a los métodos sobrecargados
objeto.prueba();
objeto.sobrecarga(29);
objeto.sobrecarga(21,19);
objeto.sobrecarga(-2.5,10.0,5.1);
}
}
La ejecución muestra la salida:
Método sin argumentos
Método con 1 argumento. x = 29
Método con 2 argumentos. x = 21; y = 19
Método con 3 argumentos. x = -2.5; y = 10.0; z = 5.1

9.7.1. Sobrecarga de constructores:

El constructor tiene el mismo nombre que la clase y no tiene tipo de retorno.
La sobrecarga de constructores normalmente se sobrecargan en la mayoría de las clases
creadas, aunque no es regla, incluso una clase puede definirse sin constructor y sin
argumentos.
Ejemplo 9.8:
Se define la clase Racional con tres constructores sobrecargados; 1 sin argumentos, otro con dos argumentos
y un tercero que es un objeto Racional.
Los números racionales se caracterizan por tener un numerador y un denominador de tipo entero. El constructor
sin argumentos inicializa el objeto al número racional 0/1; el constructor con dos argumentos enteros se encarga
del numerador y denominador respectivamente; el tercer constructor inicializa el objeto al que se pasó como
argumento.
class Racional{
private int numerador, denominador;

public Racional(){
numerador = 0;
denominador = 1;
}
public Racional(int numerador, int denominador){
this.numerador = numerador;
this.denominador = denominador;
}
public Racional(Racional r){
numerador = r.numerador;
denominador = r.denominador;
}
public Racional sumar(Racional r2){
Racional suma = new Racional(numerador + r2.numerador, denominador
+ r2.denominador);
return suma;
}

// métodos para operar con números racionales

public void mostrar (){
System.out.println(numerador + "/" + denominador);
}
}

Al crear objetos Racional se puede hacer uso de un constructor u otro según se desee inicializar; en este
programa se crean objetos y se muestran por pantalla.
class DemoRacional{
public static void main(String [] a){
Racional r1,r2,r3;
r1 = new Racional(); // crea número racional 0/1
r2 = new Racional(1,5); // crea número racional 1/5
r1 = new Racional(r2); // crea racional igual que r2
r3 = r2.sumar(r1);
System.out.print("r1 = "); r1.mostrar();
System.out.print("r2 = "); r2.mostrar();
System.out.print("r1+r2 = "); r3.mostrar();
}
}

9.8. Ámbito o alcance de variables:

Los métodos pueden definir variables para su uso interno y también pueden utilizar variables
definidas fuera del método.
Tipos de ámbitos:
- Ámbito de la clase.
- Ámbito del método.
- Ámbito del bloque.
9.8.1. Ámbito de la clase:
Ámbito de la clase => Variables instancia o declaradas en una clase, tienen como ámbito
todos los métodos de esta, esto quiere decir que se pueden usar en cualquier método, por
tanto, estas variables se pueden considerar globales.
Ejemplo:
class Radio{
int numSintonias;
int potencia;
double precio;
String marca;

public void muestra(){

System.out.println(marca);
System.out.println("Sintonias : " + numSintonias);
//...
}
//
}
Todos los métodos de la clase Radio pueden usar sin restricciones las variables:
numSintonias, potencia, precio, marca, independientemente del lugar.

Las variables las inicializa automáticamente la compilación de la clase, el valor inicial depende
de su tipo, las de tipo numérico (int, float, double) se inicializan a cero, las de tipo
boolean (false, true) a false, los array se inicializan a null.

9.8.2. Ámbito del método:

Ámbito del método => Variable definida en un método tiene como ámbito o alcance el
método, se puede utilizar desde cualquier parte de este y no se pueden utilizar fuera de su
ámbito, estas variables se consideran locales.
Ejemplo:
double producto(double v[], int n){
int k;
double p = 1.0;

for (k = 0; k < n; ){
p *= v[k];
k += 2;
}
return p;
}

En producto() las variables k y p están declaradas en el cuerpo del método, por

tanto se pueden utilizar en cualquiera de sus sentencias; los parámetros v (referencia de
un array) y n tienen también como ámbito el método.

9.8.3. Ámbito del bloque:

Ámbito del bloque => Dentro de un bloque se puede declarar cualquier tipo de variable,
esta variable solo se puede utilizar dentro del bloque y fuera no es reconocida. Los
identificadores definidos dentro de un bloque deben ser distintos a los del bloque que lo
contiene.
 Ejemplo:
String recorre(){
int i;
//

if (i > 0 || i < -10){

double t;
t = Math.sqrt(29.0);
...
}
System.out.print(" t = " + t); //error, t sólo es visible en el bloque donde se define
}