[código] Métodos (o funciones) en Java (2)

(anterior) En esta sección se ofrece un análisis más detallados de los objetos. Los objetos contienen datos llamados campos y unidades llamados métodos. En esta sección se encuentran ejemplos muy conocidos sobre recursividad. Las técnicas aquí expuestas son esenciales para producir programas correctamente estructurados, especialmente los más grandes que desarrollan los programadores de sistemas y aplicaciones. También se muestra el uso de la sobrecarga de métodos y se presentan el manejo de eventos.

Un ejemplo del alcance de las variables en métodos

// Fig. 6.10: Alcance.java
// Un ejemplo del alcance.
import java.awt.Container;
import javax.swing.*;
public class Alcance extends JApplet
{
	JTextArea areaSalida;

	// campo que es accesible para todos los métodos de esta clase
	int x = 1;
	// crear GUI del subprograma
	public void init()
	{
		areaSalida = new JTextArea();
		Container contenedor = getContentPane();
		contenedor.add( areaSalida );
	} // fin del método init

	// el método start se llama después de que init termina; start llama a
	// los métodos usarLocal and usarCampo
	public void start()
	{
		int x = 5;   // variable local en método start que sombrea el campo x

		areaSalida.append( "x local en start es " + x );

		usarLocal();  // usarLocal tiene x local
		usarCampo();  // useInstance utiliza el campo x de Alcance
		usarLocal();  // usarLocal inicializa la variable local x
		usarCampo();  // Campo x de Alcance retiene su valor

		areaSalida.append( "\n\nx local en start es " + x );
	} // fin del método start

	// usarLocal crea e inicializa la variable local x durante cada llamada
	public void usarLocal()
	{
		int x = 25;  // se inicializa cada vez que se hace una llamada a usarLocal

		areaSalida.append( "\n\nx local en usarLocal es " + x +" después de entrar a usarLocal" );
		++x;
		areaSalida.append( "\nx local en usarLocal es " + x +" después de salir de usarLocal" );

	} // fin del método usarLocal

	// usarCampo modifica el campo x de Alcance durante cada llamada
	public void usarCampo()
	{
		areaSalida.append( "\n\nel campo x es " + x +" al entrar a usarCampo" );
		x *= 10;
		areaSalida.append( "\nel campo x es " + x +" al salir de usarCampo" );
	} // fin el método usarCampo
} // fin de la clase Alcance

Descargar código fuente

Uso de métodos sobrecargados

// Uso de métodos sobrecargados
import java.awt.Container;
import javax.swing.*;
public class SobrecargaMetodos extends JApplet
{
	// crear GUI y llamar a cada uno de los métodos cuadrado
	public void init()
	{
		JTextArea areaSalida = new JTextArea();
		Container contenedor = getContentPane();
		contenedor.add( areaSalida );

		areaSalida.setText( "El cuadrado del valor integer 7 es " + cuadrado( 7 ) +"\nEl cuadrado del valor double 

7.5 es " + cuadrado( 7.5 ) );
	} // fin del método init
	// método cuadrado con argumento int
	public int cuadrado( int intValor )
	{
		System.out.println( "Se llamo a cuadrado con argumento int: " + intValor );
		return intValor * intValor;
	} // fin del método cuadrado con argumento int
	// método cuadrado con argumento double
	public double cuadrado( double doubleValor )
	{
		System.out.println( "Se llamo a cuadrado con argumento double: " +doubleValor );
		return doubleValor * doubleValor;
	} // fin del método cuadrado con argumento double
} // fin de la clase SobrecargaMetodos

Descargar código fuente

Método recursivo para el factorial

// Método recursivo para el factorial.
import java.awt.*;
import javax.swing.*;
public class PruebaFactorial extends JApplet
{
	JTextArea areaSalida;

	// crear GUI y calcular factoriales del 0-10
	public void init()
	{
		areaSalida = new JTextArea();

		Container contenedor = getContentPane();
		contenedor.add( areaSalida );

		// calcular los factoriales de 0 hasta 10
		for ( long contador = 0; contador <= 10; contador++ )
			areaSalida.append( contador + "! = " +factorial( contador ) + "\n" );
	} // fin del método init

	// declaración recursiva del método factorial
	public long factorial( long numero )
	{
		// caso base
		if ( numero <= 1 )
			return 1;
		// paso recursivo
		else
			return numero * factorial( numero - 1 );
	} // fin del método factorial
} // fin de la clase PruebaFactorial

Descargar código fuente

Método recursivo fibonacci

// Método recursivo fibonacci.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class PruebaFibonacci extends JApplet implements ActionListener
{
	JLabel numeroEtiqueta, resultadoEtiqueta;
	JTextField numeroCampo, resultadoCampo;

	// configurar la GUI del subprograma
	public void init()
	{
		// obtener el panel de contenido y establecer su esquema como FlowLayout
		Container contenedor = getContentPane();
		contenedor.setLayout( new FlowLayout() );

		// crear numeroEtiqueta y adjuntarlo al panel de contenido
		numeroEtiqueta = new JLabel( "Escriba un entero y oprima Intro" );
		contenedor.add( numeroEtiqueta );

		// crear numeroCampo y adjuntarlo al panel de contenido
		numeroCampo = new JTextField( 10 );
		contenedor.add( numeroCampo );

		// registrar este subprograma como ActionListener de numeroCampo
		numeroCampo.addActionListener( this );

		// crear resultadoEtiqueta y adjuntarlo al panel de contenido
		resultadoEtiqueta = new JLabel( "El valor de Fibonacci es" );
		contenedor.add( resultadoEtiqueta );

		// crear numeroCampo, hacerlo no editable
		// y adjuntarlo al panel de contenido
		resultadoCampo = new JTextField( 15 );
		resultadoCampo.setEditable( false );
		contenedor.add( resultadoCampo );
	} // fin del método init

	// obtener entrada del usuario y llamar al método fibonacci
	public void actionPerformed( ActionEvent event )
	{
		long numero, valorFibonacci;

		// obtener entrada del usuario y convertirla en long
		numero = Long.parseLong( numeroCampo.getText() );
		showStatus( "Calculando ..." );

		// calcular valor de fibonacci para el número introducido por el usuario
		valorFibonacci = fibonacci( numero );
		// indicar que el procesamiento se completó y mostrar el resultado
		showStatus( "Listo." );
		resultadoCampo.setText( Long.toString( valorFibonacci ) );

	} // fin del método actionPerformed

	// declaración recursiva del método fibonacci
	public long fibonacci( long n )
	{
		// caso base
		if ( n == 0 || n == 1 )
			return n;
		// paso recursivo
		else
			return fibonacci( n - 1 ) + fibonacci( n - 2 );
	} // fin del método fibonacci
} // fin de la clase PruebaFibonacci

Descargar código fuente

23 Comentarios | deja el tuyo