Вы находитесь на странице: 1из 12

While

import java.io.*;
/**
*
* @author PC
*/
public class Main {

/** Creates a new instance of Main */


public Main() {
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) throws IOException {
// TODO code application logic here
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader tec=new BufferedReader(isr);
// Programa que realiza un algoritmo que permite encontrar el valor de la siguiente
serie: -1!+2!-3!+4!...+n;
// donde n debe ser el número máximo ingresado por teclado.

Int cont,num,b,f,se;
System.out.println(“Programa que resuelve una serie numérica”);
f=1;
System.out.println(“Ingrese el número máximo de la serie”);
num=Integer.parseInt(tec.readLine());
if(num>=0){
cont=0;
b=0;
se=0;
while(cont<num){
cont++;
if(b==0){
f=f*cont*-1;
b=1;
se=se+f;
}
else{
f=f*cont*-1;
b=0;
se=se+f;
}
}
System.out.println(“El valor de la serie es: “ +se);
}

}
for
import java.io.*;
import java.security.interfaces.DSAKey;
public class Main {
* @param args the command line arguments
*/
public static void main(String[] args) throws IOException{
// TODO code application logic here
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader tec=new BufferedReader(isr);
// Programa sobre el promedio de notas de alumnos, número de aprobados y
desaprobados,
// y promedio general del curso.
System.out.println(“Programa sobre el promedio de notas de alumnos”);
int n,t,cont,contn,a,dsa;
double p,nota,pa,pd,pt,promc;
System.out.println(“Ingresar número de estudiantes”);
n=Integer.parseInt(tec.readLine());
System.out.println(“Ingresar número de notas”);
t=Integer.parseInt(tec.readLine());
p=0; a=0; pa=0; dsa=0; pd=0; pt=0; promc=0;
for(cont=0;cont<n;cont++){
for(contn=0;contn<t;contn++){
System.out.println(“Ingresar nota”);
nota=Double.parseDouble(tec.readLine());
p=p+nota;
pt=p/t;
}
p=0;
if(pt>=7){
a++;
pa=pa+pt;
System.out.println(“aprueba”);
}
else{
dsa++;
pd=pd+pt;
System.out.println(“Desaprueba”);
}
System.out.println(“promedio total del estudiante es: “ +pt);
System.out.println(“Siguiente estudiante”);
}
System.out.println(“El número de aprobados es: “ +a);
System.out.println(“El número de desaprobados es: “ +dsa);
promc=(pa+pd)/n;
System.out.println(“El promedio total del curso es: “ +promc);

}
}
do while
import java.io.*;
/**
*
* @author PC
*/
public class Main {

/** Creates a new instance of Main */


public Main() {
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) throws IOException {
// TODO code application logic here
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader tec=new BufferedReader(isr);
// Programa que realiza un algoritmo que permite encontrar el valor de la siguiente
// serie: 2+5+7+10+12+15+17...+n;
// donde n debe ser el número de veces que va a sumar la serie.

int cont,num,s,r,b;
System.out.println("Programa que resuelve una serie numérica");
System.out.println("Ingrese el número de veces que debe ser sumada la serie");
num=Integer.parseInt(tec.readLine());
if(num%10==0){
s=0;
b=0;
cont=2;
{
s=s+cont;
if(b==0){
cont+=3;
b=1;
}
else{
cont+=2;
b=0;
}
System.out.println("El valor de la serie es: " +s);}
do while(cont<num){

}
}

}
}
Métodos de Programación.

Los métodos son un bloque de código que contiene una serie de instrucciones.

En C#, cada instrucción se ejecuta en el contexto de un método.

Los métodos se declaran en una clase o estructura especificando:


El nivel de acceso, el valor devuelto, el nombre del método y los parámetros de método.
Los parámetros de método se incluyen entre paréntesis y separados por comas. Los
paréntesis vacíos indican que el método no requiere ningún parámetro. Esta clase
contiene tres métodos:

class Motorcycle

public void StartEngine() { }

public void AddGas(int gallons) { }

public int Drive(int miles, int speed) { return 0; }

Llamar a un método en un objeto es similar a tener acceso a un campo. Después del


nombre de objeto, agregue un punto, el nombre del método y paréntesis. Los
argumentos se enumeran entre paréntesis y separados por comas. Por tanto, se puede
llamar a los métodos de la clase Motorcycle del modo siguiente:

Motorcycle moto = new Motorcycle();

moto.StartEngine();

moto.AddGas(15);

moto.Drive(5, 20);

Parámetros de métodos
Como se muestra en el fragmento de código anterior, para pasar argumentos a un
método simplemente hay que proporcionarlos entre paréntesis cuando se llama al
método. En el método al que se llama, los argumentos de entrada se denominan
parámetros.

Los parámetros que un método recibe también se proporcionan entre paréntesis, pero se
debe especificar el tipo y nombre de cada parámetro. El nombre no tiene por qué ser
igual que el argumento. Por ejemplo:
public static void PassesInteger()

int fortyFour = 44;

TakesInteger(fortyFour);

static void TakesInteger(int i)

i = 33;

Aquí un método denominado PassesInteger pasa un argumento a un método


denominado TakesInteger. En PassesInteger el argumento se denomina fortyFour, pero
en TakeInteger es un parámetro denominado i. Este parámetro sólo existe dentro del
método TakesInteger. Otras variables también pueden denominarse i y pueden ser de
cualquier tipo, siempre y cuando no sean parámetros o variables declaradas en ese
método.

Observe que TakesInteger asigna un nuevo valor al argumento proporcionado. Se podría


esperar que este cambio se reflejara en el método PassesInteger una vez que
TakeInteger devuelve un valor, pero de hecho, el valor de la variable fortyFour se
mantiene sin cambios. Esto se debe a que int es un tipo de valor. De forma
predeterminada, cuando un tipo de valor se pasa a un método, se pasa una copia en lugar
del propio objeto. Dado que son copias, cualquier cambio realizado en el parámetro no
tiene ningún efecto en el método de llamada. Los tipos de valor reciben su nombre del
hecho de que se pasa una copia del objeto en lugar del propio objeto. Se pasa el valor,
pero no el objeto mismo.

Esto es diferente de los tipos de referencia, que se pasan por referencia. Cuando un
objeto basado en un tipo de referencia se pasa a un método, no se realiza ninguna copia
del objeto. En su lugar, se hace una referencia al objeto que se utiliza como argumento
del método y se pasa dicha referencia. Los cambios realizados a través de esta
referencia se reflejarán por consiguiente en el método de llamada. Un tipo de referencia
se crea con la palabra clave class, de la forma siguiente:
public class SampleRefType

public int value;

Ahora, si un objeto basado en este tipo se pasa a un método, se pasará por referencia.
Por ejemplo:

public static void TestRefType()

SampleRefType rt = new SampleRefType();

rt.value = 44;

ModifyObject(rt);

System.Console.WriteLine(rt.value);

static void ModifyObject(SampleRefType obj)

obj.value = 33;

Este ejemplo hace esencialmente lo mismo que el ejemplo anterior. Pero, como se
utiliza un tipo de referencia, la modificación realizada por ModifyObject se efectúa en
el objeto creado en el método TestRefType. Por consiguiente, el método TestRefType
mostrará el valor 33.

Valores devueltos:
Los métodos pueden devolver un valor al llamador. Si el tipo de valor devuelto (el que
aparece antes del nombre de método) no es void, el método puede devolver el valor
mediante la palabra clave return. Una instrucción con la palabra clave return, seguida
de un valor que coincida con el tipo de valor devuelto, devolverá ese valor al llamador
del método. La palabra clave return también detiene la ejecución del método. Si el tipo
de valor devuelto es void, una instrucción return sin ningún valor sigue siendo útil para
detener la ejecución del método. Sin la palabra clave return, el método detendrá la
ejecución cuando llegue al fin del bloque de código. Es necesario que los métodos con
un tipo de valor devuelto no nulo utilicen la palabra clave return para devolver un
valor. Por ejemplo, estos dos métodos utilizan la palabra clave return para devolver
enteros:

class SimpleMath

public int AddTwoNumbers(int number1, int number2)

return number1 + number2;

public int SquareANumber(int number)

return number * number;

Para emplear un valor devuelto por un método, el método de llamada puede utilizar la
propia llamada del método en cualquier parte donde un valor del mismo tipo sea
suficiente. El valor devuelto también se puede asignar a una variable. Por ejemplo, los
dos ejemplos de código siguientes logran el mismo objetivo:

int result = obj.AddTwoNumbers(1, 2);

obj.SquareANumber(result);

obj.SquareANumber(obj.AddTwoNumbers(1, 2));

El uso de una variable intermedia, en este caso result, para almacenar un valor es
opcional. La legibilidad del código puede ser útil o puede ser necesaria si el valor se va
a utilizar más de una vez.
Métodos de Programación.
Los métodos de programación en Java están en toda la lógica de programación
(Algoritmos) agrupados en funciones o métodos.

Método.- Un método es un bloque de código que tiene un nombre, recibe unos


parámetros o argumentos (opcionalmente), contiene sentencias o instrucciones para
realizar algo (opcionalmente) y devuelve un valor de algún Tipo conocido
(opcionalmente).

La sintaxis global es:

Tipo_Valor_devuelto  nombre_método ( lista_argumentos ) {


        bloque_de_codigo;
}
La lista de argumentos se expresa declarando el tipo y nombre de los mismos (como en
las declaraciones de variables). Si hay más de uno se separan por comas. Ejemplo:
int sumaEnteros( int a, int b ){
        int c = a + b;
        return c;
}

-El método se llama suma de Enteros.


-Recibe dos parámetros también enteros. Sus nombres son a y b.
-Devuelve un entero. 

En el ejemplo la cláusula return se usa para finalizar el método devolviendo el valor de


la variable c.

Funcionamiento:

Los métodos son las acciones que la computadora aprende a hacer,; particularmente se
crean los métodos, como la acción que la computadora aprende a ejercer, más no
específicamente para que lo haga con
determinados valores, cuando invocamos al método estamos además de llamarlo,
estamos pasándole valores coherentes con el tipo de dato que se
tiene como argumento Es así como entonces, podemos emplear un solo método para
analizar una gran cantidad de datos.
Los métodos se invocan con su nombre, y pasando la lista de argumentos entre
paréntesis. El conjunto se usa como si fuera una variable del Tipo devuelto por el
método. Por ejemplo:
int x;
x = sumaEnteros(2,3);

Nota: Esta sintaxis no está completa, pero sirve para nuestros propósitos en este
momento. La sintaxis completa se verá cuando se hable de objetos.
Aunque el método no reciba ningún argumento, los paréntesis en la llamada son
obligatorios. Por ejemplo para llamar a la función hacealgo, simplemente se pondría:
hacealgo();

Obsérvese que como la función tampoco devuelve ningún valor no se asigna a ninguna
variable. (No hay nada que asignar).

El termino void:
El hecho de que un método devuelva o no un valor es opcional. En caso de que
devuelva un valor se declara el tipo que devuelve. Pero si no necesita ningún valor, se
declara como tipo del valor devuelto, la palabra reservada void. Por ejemplo: 
   void hacealgo() {
        . . .
    }
Cuando no se devuelve ningún valor, la cláusula return no es necesaria. Obsérvese que
en el ejemplo el método hacealgo tampoco recibe ningún parámetro. No obstante los
paréntesis, son obligatorios.

Tipos de retorno de los métodos:

Los métodos generalmente tienen dos tipos de retorno, el void, que no regresa ningún
valor, y el return~algo.

VOID:
Una declaración típica de un método de tipo void es la siguiente

public void metodo(){


}

La forma de invocación de éstos métodos es la siguiente:

instancia.metodo();

Generalmente los métodos void se pueden encontrar en la clase donde se encuentra el


método constructor, en donde se modifican los valores que son creados en el mismo
constructor.
Un ejemplo real de la implementación de éste método es:

import java.math.*;
public class Factura {

int dia;
int mes;
int anyo;
float Monto;
float iva;
float total;//CONSTRUCTOR
public Factura(int dd, int mm, int aaaa, float monto, float Iva, float
Total){
dia=dd;
mes=mm;
anyo=aaaa;
Monto=monto;
iva=Iva;
total=Total;
}
//FIN DE CONSTRUCTOR
//Comienza fase de métodos
//1°er Método, modifica los elementos de las facturas

public void Crear(){


dia=1+(int)(Math.random()*29);
mes=1+(int)(Math.random()*12);
anyo=1997+(int)(Math.random()*30);
Monto=1+(float)(Math.random()*5000);
}

public void Iva(){ //Este metodo void, modifica los valores del monto
creado antes, por el constructor
iva= (float)(Monto*0.15);
}

public void Total(){


total=Monto+iva;
}

public void Imprime(){


System.out.println("\t"+dia+"/"+mes+"/"+anyo+"\t"+Monto+"\t\t"+iva+"\t
\t"+total);
}
}

Algoritmos que regresan un valor:

Para estos algoritmos, su implementación básica es la siguiente:

public static (Tipo de retorno: int,char,boolean)


NombreMetodo(Argumento [no necesita ser del mismo tipo de retorno]){
(Tipo de retorno) variable; //Aqui declaro una variable delnuevo
debian tipo de retorno elegido
//Comandos propios del método
return variable; //Aqui es donde regresa la variable
}
Para invocarlos, es sencillo:
NombreClase.metodo(argumento);

Un ejemplo real de este tipo de algoritmo es el siguiente:

class prbprimo1
{
public static void main(String args[])
{
for(int i = 1; i <= 157; i++ )
if (primo(i) == true) System.out.println(i);
}

public static boolean primo(int num)


{
boolean p;

int contador = 0;
int i = 1;
while(i <= num)
{
if (num % i == 0) contador++;
i++;
System.out.println("Counter es"+contador);
}
if (contador <= 2){ p = true;
System.out.print("aqui alcance mi maximo ki\n");}
else p = false;
return p;
}
}

Una clase en Java puede contener variables y métodos. Las variables pueden ser tipos
primitivos como int, char, etc. Los métodos son funciones.
Por ejemplo, en el siguiente trozo de código podemos observarlo:
public MiClase {
int i;
public MiClase() {
i = 10;
}
public void Suma_a_i( int j ) {
i = i + j;
}
}

La clase MiClase contiene una variable (i) y dos métodos, MiClase que
es el constructor de la clase y Suma_a_i( int j ).

Métodos y Constructores:

Los métodos son funciones que pueden ser llamadas dentro de la clase o por otras
clases. El constructor es un tipo específico de método que siempre tiene el mismo
nombre que la clase.
Cuando se declara una clase en Java, se pueden declarar uno o más constructores
opcionales que realizan la inicialización cuando se instancia (se crea una ocurrencia) un
objeto de dicha clase.
Utilizando el código de ejemplo anterior, cuando se crea una nueva instancia de
MiClase, se crean (instancian) todos los métodos y variables, y se llama al constructores
de la clase:
MiClase mc;
mc = new MiClase();
La palabra clave new se usa para crear una instancia de la clase. Antes de ser
instanciada con new no consume memoria, simplemente es una declaración de tipo.
Después de ser instanciado un nuevo objeto mc, el valor de i en el objeto mc será igual a
10. Se puede referenciar la variable (de instancia) i con el nombre del objeto:
mc.i++; // incrementa la instancia de i de mc

Al tener mc todas las variables y métodos de MiClase, se puede usar la primera sintaxis
para llamar al método Suma_a_i() utilizando el nuevo nombre de clase mc:
mc.Suma_a_i( 10 );

y ahora la variable mc.i vale 21.

Finalizadores:
Java no utiliza destructores (al contrario que C++) ya que tiene una forma de recoger
automáticamente todos los objetos que se salen del alcance. No obstante proporciona un
método que, cuando se especifique en el código de la clase, el reciclador de memoria
(garbage collector) llamará:
// Cierra el canal cuando este objeto es reciclado
protected void finalize() {
close();
}

Вам также может понравиться