UNIVERSIDAD PRIVADA ANTENOR ORREGO

INGENIERÍA DE COMPUTACIÓN Y SISTEMAS

FUNDAMENTOS DE PROGRAMACIÓN II

MÉTODOS (FUNCIONES)

Uso de un método.

Para usar un método, se aplica siempre a través del uso un objeto de una clase determinada
por medio del operador punto (.).
Para usar un método se hace invocando
nombre_objeto . nombre_método (parámetros actuales);
y enviándole los valores necesarios para su normal funcionamiento..
El acto de invocar a un método suele denominarse envío de un mensaje a un objeto.
Al ser invocado un método, los parámetros actuales se copian en los parámetros formales
para que la función pueda realizar los cálculos necesarios y luego devuelve el valor calculado
a través del nombre del método.

Ámbito de las variables

En java se disponen de tres tipos de variables:

-Variables miembros, pertenecientes a una clase.
-Argumentos de un método de la clase.
-Variables locales de un método de la clase.

Los argumentos trabajan como variables locales de un método.

Ejemplo:

class Ejemplo
{ int x; // Variable miembro

void metodo ( int y ) // Parámetro formal de un método

{
int z; // variable local

x= y + z;
}
}

Las variables miembro, son visibles (accesibles) desde cualquier parte de la clase.
Los argumentos y variables locales solo son visibles (accesibles) dentro del método al que
pertenecen. Dejan de existir cuando termina el método.
Dentro de un método, si coincide el identificador de un argumento o variable local con el de
una variable miembro, solo se accede a la variable local del método.

1
Ejemplo 1:
Escribir un programa utilizando funciones que permita calcular e imprimir los n primeros
2 3 4 5 n
términos de la serie: X + X / 2! + X / 3! + X / 4! + X / 5! ................. X / n!
También debe imprimir la suma de los n términos.

Inicio leenum( )

Variables n, suma = 0, x , num=1, p , f Variables n

n = leenum( ) leer n

leer x n≤0

p = potencia( x, num ) retornar n

f = factorial (num)
potencia ( x, n)
Imprimir p, ‘/’ , f
Variables cont=0 , p=1
suma = suma + p / f
cont < n
num = num + 1
num ≤ n p=p*x

Imprimir suma cont = cont + 1

Fin retornar p

factorial ( n )

Variables f=1 , cont = 1

cont ≤ n

f = f*cont

cont = cont +1

retornar f

2
Código en Java
import java.io.*;
public class metodos1_serie{
static int leenum( ) throws IOException
{BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int n;
System.out.println("ingrese numero...");
n= Integer.parseInt(br.readLine());
return n;
}
/************************************/
static int factorial(int n) throws IOException
{ int f=1, cont=1;
while(cont<=n)
{f=f*cont;
cont++;
}
return f;
}
/************************************/
static double potencia(float x, int n) throws IOException
{ int cont=0;
double p=1.0;
while(cont<n)
{ p=p*x;
cont++;
}
return p;
}
/************************************/
public static void main(String[] args)throws IOException
{ BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int n, num=1,f;
double p,suma=0;
float x;
n=leenum();
System.out.println("ingrese numero X =");
x= Float.parseFloat(br.readLine());
do{p=potencia(x,num);
f=factorial(num);
System.out.print(p+"/"+f+" , ");
suma=suma + (double)p/f;
num++;
} while(num<=n);
System.out.println("Suma = "+suma);
}
}

3
Ejemplo 2:
Escribir un programa utilizando funciones que permita calcular e imprimir los n primeros términos de
la serie: X + X 2/ 2! + X 3 / 3! + X 4 / 4! + X 5 / 5! ................. X n / n! . También debe imprimir la
suma de los n términos. El programa se debe repetir mientras se desee continuar.

Inicio

Variables n, suma, x, num, p, f, resp leenum( )

suma = 0 Variables n
num = 1
leer n
n = leenum( )
leer x n≤0

p = potencia( x, num ) retornar n

f = factorial (num)
potencia ( x, n)
Imprimir p, ‘/’ , f
Variables cont=0 , p=1
suma = suma + p / f
cont < n
num = num + 1
num ≤ n p=p*x

Imprimir suma cont = cont + 1

resp = continuar( ) retornar p

resp = ‘S’

Fin factorial ( n )

Variables f=1 ,cont = 1

continuar( )
cont ≤ n
variables resp
Escribir : f = f * cont
"Desea Continuar S/N ? "
cont = cont +1

leer resp retornar f

resp ≠ ‘S’ ^ resp ≠ ‘N’

retornar resp

4
Código en Java
import java.io.*;

public class metodos2_serie

{
static int leenum( ) throws IOException
{BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int n;
System.out.println("ingrese numero ...");
n= Integer.parseInt(br.readLine()); return
n;
}

/************************************/
static int factorial(int n) throws IOException
{ int f=1, cont=1;
while(cont<=n)
{f=f*cont;
cont++;
}
return f;
}

/************************************/
static double potencia(float x, int n) throws IOException
{ int cont=0;
double p=1.0;
while(cont<n)
{ p=p*x;
cont++;
}
return p;
}

/************************************/
static char continuar( ) throws IOException
{ BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
char resp;
String cad;
do {System.out.print("\nDesea Continuar...S/N ? : ");
cad = br.readLine(); // lee una cadena de caracteres en cad.
cad = cad.toUpperCase(); //convierte la cadena cad a Mayúsculas
resp = cad.charAt(0); //selecciona el primer carácter de cad
}
while (resp!='S' && resp!='N');
return resp;
}

/************************************/

5
public static void main(String[ ] args)throws IOException
{ BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int n, num,f;
double p,suma;
float x;
char resp:
do{ suma=0;
num=1;
n=leenum();
System.out.println("ingrese numero X =");
x= Float.parseFloat(br.readLine());
do{ p=potencia(x,num);
f=factorial(num);
System.out.print(p+"/"+f+" , ");
suma=suma + (double)p/f;
num++;
} while(num<=n);
System.out.println("Suma = "+suma);
resp= continuar( );
}
While(resp = =’S’);
}
/************************************/

6
 Ejemplo 3:
Escribir un programa utilizando funciones que calcule e imprima los n primeros términos de
la serie de fibonacci: 1, 1, 2, 3, 5, 8, 13, 21 .....
También debe imprimir la suma de los n términos y el programa se debe repetir mientras se
desee hacerlo.

Inicio leenum( )

Variables n , resp , suma variables n

n = leenum ( ) leer n

suma = fibonacci ( n ) n≤0

reportar (suma)
retornar n
resp = continuar( )
fibonacci ( n )
resp = ‘S’
Fin f1=0, f2 = 0, term =1
variables
sum = 0 , cont = 0

continuar ( ) Escribir: term

variables resp sum = sum + term

Imprimir: cont = cont + 1

“Desea continuar S/N?”
f1 = f2
leer resp
f2 = term
resp ≠ ‘S’ ^ resp ≠ ‘N’
term = f1 + f2
retornar res
cont < n

reportar ( suma) retornar sum

variables
escribir: suma
retornar

7
Código en Java
import java.io.*;
public class metodos3_fibonacci
{
static int leenum( ) throws IOException
{ BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int n;
do{System.out.print("\nIngrese numero :");
n= Integer.parseInt(br.readLine());
}
while(n<=0);
return n;
}
/**************************/
static int fibonacci(int n) throws IOException
{ int f1=0, f2=0, term=1, sum=0,cont=0;
System.out.println("Los "+n+" terminos de la serie son: ");
do
{System.out.print(" "+term);
sum = sum + term;
cont++;
f1=f2;
f2=term;
term=f1+f2;
}
while(cont<n);
return sum;
}
/**************************/
static void reportar(int suma) throws IOException
{
System.out.println("\nLa suma de los terminos es = "+suma);
}

/**************************/
static char continuar( ) throws IOException
{ BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
char resp;
String cad;
do {System.out.print("\nDesea Continuar...S/N ? : ");
cad = br.readLine(); // lee una cadena de caracteres en cad.
cad = cad.toUpperCase(); //convierte la cadena cad a Mayúsculas
resp = cad.charAt(0); //selecciona el primer carácter de cad
}
while (resp!='S' && resp!='N');
return resp;
}

8
 public static void main(String[] args)throws IOException
{ int n,suma;
char resp;
System.out.println("Programa que imprime la serie Fibonacci ");
do { n = leenum( );
suma=fibonacci(n);
reportar(suma);
resp=continuar( );
}
while(resp= ='S');
}
}