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.

Au nque 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 { t dia; int mes; int anyo; float Monto; float iva; float total;//CONSTRUCTOR in

publ ic 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 lic 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); } blic void Iva(){ //Este metodo void, modifica los valores del monto creado antes, por el constructor iva= (float)(Monto*0.15); } ublic void Total(){ total=Monto+iva; } p pub

pu

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; nt 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; } } i

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: L os 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(); }

Sign up to vote on this title
UsefulNot useful