4.- Metodos

Haciendo uso de libros, foros,
wikis, blogs, webquest, artículos
científicos, o algunas otras TICs, el
estudiante debe investigar los
conceptos básicos de la
programación orientada a objetos y
sintaxis en lenguaje Java y
Python, para todo lo concerniente
a los Métodos. Debe indagar al
menos dos de los siguientes temas
para presentar en este Foro y en
plenaria durante alguna clase: Los
temas son:
- Definición de un método, //
- Estructura de un método, //
- Valor de retorno, //
- Declaración de un método, //
- ámbito y tiempo de vida de
variables, //
- Argumentos y paso de
parámetros, //
- Sobrecarga de métodos, // - y ,
- Encapsulamiento.
////// Procure analizar la
información de distintas fuentes
(incluyendo un segundo idioma)
para seleccionar la más
conveniente y que sea adecuada
al área de Informática. Elabore un
resumen o análisis o síntesis o
reflexión o tabla comparativa o
cuadro sinóptico (estilo inducción-
deducción) o mapa conceptual o
mapa mental, que permitan
promover el pensamiento crítico o
posición critica del estudiante, el
cual debe compartir en este Foro.
NOTA: Procure participar con
reactivos que aún no hayan sido
contestados, ya que solamente se
considerarán las primeras tres
participaciones.
Atte: M.C. Edgar Rangel Lugo .

Definición de métodos
Este es un ejemplo de una declaración de método normal:
public double calculateAnswer(double wingSpan, int numberOfEngines, double length, double grossTons) {
// aquí se realizan los cálculos
}

Los únicos elementos requeridos de una declaración de método son su tipo de retorno, su nombre, una pareja de paréntesis, () y un cuerpo entre corchetes {}.
Las declaraciones de métodos tienen, en general, seis componentes, en este orden:

Modificadores, como public, private y otros que se comentarán más adelante.
El tipo de retorno, el tipo de dato del valor devuelto por el método, o void si el método no devuelve ningún valor.
El nombre del método—las reglas de nomenclatura de campos también se aplica a los nombres de métodos, pero el convenio difiere un poco.
La lista de parámetros entre paréntesis—una lista, separada por comas, de parámetros de entrada, precedidos por su tipo de dato, encerrado entre paréntesis (). Si no hay parámetros se deben utilizar paréntesis vacios.
Una lista de excepciones—se verá más tarde.
El cuerpo del método, encerrado entre llaves—aquí va el código del método, incluyendo la declaración de variables locales

Tarde compañeros pero seguro ,,,este es mi comentario de la unidad 4 que se
llama:
MÉTODOS
Es un conjunto de código reutilizable del cual se puede hacer un uso continuo
que se encuentra disponible en cualquier momento deseado dentro de la
aplicación.
EJEMPLO DE MÉTODOS
Veamos un ejemplo, primero creemos un método que realice la suma de dos
números, el código sería el siguiente:
private void MetodoSuma(float numero1, float numero2){
float Suma=numero1+numero2;
System.out.println(Suma);
}
Que son los métodos y cómo utilizarlos en java
Java como todo lenguaje de programación orientado a objetos utiliza los
llamados metodos. Acontinuación veremos como se crea un metodo y como
se utilizan.
Se podria decir que existen 2 grandes tipos de metodos, el primer tipo de
metodo son metodos que realizan procesos, puedes realizar cualquier operación
con ellos, sin embargo el proposito es manipular variables existentes. El
segundo tipo de metodos son los que realizan un proceso o calculo, y calculan
una variable especifica, un ejemplo podria ser un metodo para obtener el
valor de una multiplicación.
Estructura de un metodo
Los metodos en java pueden tener parametros, es decir, que un metodo
puede utilizar variables predefinidas para ser utilizadas en sus procesos,
Veamos un ejemplo de como hacer un metodo en el siguiente ejemplo
En este ejemplo vemos un programa normal en el cual se ejecuta un ciclo
while que imprime numeros del 0 al 7, pero ¿es posible hacerlo utilizando un
metodo?
01 package ciclos;
02
03 /**
04 *
05 * @author xymind
06 */
07 public class Main {
08
09 /**
10 * @param args the command line arguments
11 */
12 public static void main(String[] args) {
13
14 int x=0;
15 while(x!=7)
16 {
17 System.out.println("X vale: "+x);
18 x++;
19
20 }
21 }
22
23 }
Ahora utilizaremos este mismo programa pero el ciclo se ejecutara en un
metodo:
01 package ciclos;
02
03 /**
04 *
05 * @author xymind
06 */
07 public class Main {
08
09 /**
10 * @param args the command line arguments
11 */
12 public static void main(String[] args) {
13
14 iniciarCiclo();//aqui estamos ejecutando el metodo escrito en
15 //la parte de abajo, se puede utilizar mas de 1 vez
16 }
17
18 /*Comienza el metodo
19 Este metodo no regresa valores, es un metodo que unicamente
20 realiza un procedimiento, por lo que se declara como "void" seguido del
21 nombre que tendra el metodo*/
22 public void iniciarCiclo(){
23
24 int x=0;
25 while(x!=7)
26 {
27 System.out.println("X vale: "+x);
28 x++;
29
30 }
31 }
32
33 }
Los dos anteriores programas hacen exactamente lo mismo a diferencia de
que el segundo programa esta utilizando un metodo.
En este ultimo ejemplo se mostrara un metodo que regrese un valor, estos
metodos se declaran diferente y siempre deben terminar
con la palabra “return var;” donde “var” es una variable cualquiera del
mismo tipo del metodo. Ejemplo:
Declaramos el metodo:
..//
1 public int obtenerValor(){
2 int x=10;
3 return x;
4 }
//..
Notese que se utiliza “int” en lugar de “void”, lo cual indica que se regresara
una variable del tipo integer o numerico, por lo que dentro del metodo se
declara int x=10; que es precisamente un valor numerico, y se ,ETC...
Lindas vacaciones!!!!

Los felicito por sus participaciones. Y recomiendo para la próxima ocasión citar más fuentes bibliográficas que respalden el contenido de sus participaciones.

Y nuevamente, los felicito!!!

ATTE:

M.C. Edgar Rangel Lugo.

estan muy buenos los conseptos

Un método tiene la siguiente sintaxis:
-------------------------------------------------------
public void [nombre del método]() {
 [algoritmo]
}
-----------------------------------------------------
Hay varios tipos de métodos:
Métodos con parámetros.
Un método puede tener parámetros:
--------------------------------------------------------
public void [nombre del método]([parámetros]) {
 [algoritmo]
}
----------------------------------------------------------
Los parámetros los podemos imaginar cómo variables locales al método, pero su valor se inicializa con datos que llegan cuando lo llamamos.
Problema 1:
--------------------------------------
Confeccionar una clase que permita ingresar valores enteros por teclado y nos muestre la tabla de multiplicar de dicho valor. Finalizar el programa al ingresar el -1.
-------------
Programa:
---------------
import java.util.Scanner;
public class TablaMultiplicar {
   public void cargarValor() {
       Scanner teclado=new Scanner(System.in);
       int valor;
       do {
           System.out.print("Ingrese valor:");
           valor=teclado.nextInt();
           if (valor!=-1) {
               calcular(valor);
           }
       } while (valor!=-1);
   }
   
   public void calcular(int v) {
       for(int f=v;f<=v*10;f=f+v) {
           System.out.print(f+"-");
       }
   }
   
   public static void main(String[] ar) {
       TablaMultiplicar tabla;
       tabla=new TablaMultiplicar();
       tabla.cargarValor();
   }
}
----------------------------------------
En esta clase no hemos definido ningún atributo, ya que el objeto de la clase Scanner lo requerimos en un solo método, por ello lo definimos como una variable local.
El método calcular recibe un parámetro de tipo entero, luego lo utilizamos dentro del método para mostrar la tabla de multiplicar de dicho valor, para esto inicializamos la variable f con el valor que llega en el parámetro. Luego de cada ejecución del for incrementamos el contador f con el valor de v.
------------------------------------------------
   public void calcular(int v) {
       for(int f=v;f<=v*10;f=f+v) {
           System.out.print(f+"-");
       }
   }
-----------------------------------------------
Un método puede no tener parámetros como hemos visto en problemas anteriores o puede tener uno o más parámetros (en caso de tener más de un parámetro los mismos se separan por coma)
El método cargarValores no tiene parámetros y tiene por objetivo cargar un valor entero por teclado y llamar al método calcular para que muestre la tabla de multiplicar del valor que le pasamos por teclado:
-------------------------------------------
   public void cargarValor() {
       Scanner teclado=new Scanner(System.in);
       int valor;
       do {
           System.out.print("Ingrese valor:");
           valor=teclado.nextInt();
           if (valor!=-1) {
               calcular(valor);
           }
       } while (valor!=-1);
   }
---------------------------------------------------
Como vemos al método calcular lo llamamos por su nombre y entre paréntesis le pasamos el dato a enviar (debe ser un valor o variable entera)
En este problema en la main solo llamamos al método cargarValor, ya que el método calcular luego es llamado por el método cargarValor:
--------------------------------------------------
   public static void main(String[] ar) {
       TablaMultiplicar tabla;
       tabla=new TablaMultiplicar();
       tabla.cargarValor();
   }
--------------------------------------------------
Métodos que retornan un dato.
Un método puede retornar un dato:
----------------------------------------------------
public [tipo de dato] [nombre del método]([parámetros]) {
 [algoritmo]
 return [tipo de dato]
}
------------------------------------------------------
Cuando un método retorna un dato en vez de indicar la palabra clave void previo al nombre del método indicamos el tipo de dato que retorna. Luego dentro del algoritmo en el momento que queremos que finalice el mismo y retorne el dato empleamos la palabra clave return con el valor respectivo.
------------------------------------------------------------
Problema 2:
-----------------------------------------------------------
Confeccionar una clase que permita ingresar tres valores por teclado. Luego mostrar el mayor y el menor.
Programa:
-----------------------------------------------------------
import java.util.Scanner;
public class MayorMenor {
   public void cargarValores() {
    Scanner teclado=new Scanner(System.in);
       System.out.print("Ingrese primer valor:");
       int valor1=teclado.nextInt();
       System.out.print("Ingrese segundo valor:");
       int valor2=teclado.nextInt();
       System.out.print("Ingrese tercer valor:");
       int valor3=teclado.nextInt();
       int mayor,menor;
       mayor=calcularMayor(valor1,valor2,valor3);
       menor=calcularMenor(valor1,valor2,valor3);
       System.out.println("El valor mayor de los tres es:"+mayor);
       System.out.println("El valor menor de los tres es:"+menor);
   }
   
   public int calcularMayor(int v1,int v2,int v3) {
       int m;
       if(v1>>v2 && v1>v3) {
         m=v1;
       } else {
           if(v2>v3) {
               m=v2;
           } else {
            m=v3;
           }
       }
       return m;
   }
   
   public int calcularMenor(int v1,int v2,int v3) {
       int m;
       if(v1<v2 && v1<v3) {
         m=v1;
       } else {
           if(v2<v3) {
               m=v2;
           } else {
            m=v3;
           }
       }
       return m;
   }
   
   public static void main(String[] ar) {
       MayorMenor maymen=new MayorMenor();
       maymen.cargarValores();
   }
}
---------------------------------------------------
Si vemos la sintaxis que calcula el mayor de tres valores enteros es similar al algoritmo visto en conceptos anteriores:
------------------------------------------------------
   public int calcularMayor(int v1,int v2,int v3) {
       int m;
       if(v1>v2 && v1>v3) {
         m=v1;
       } else {
           if(v2>v3) {
               m=v2;
           } else {
            m=v3;
           }
       }
       return m;
   }
----------------------------------------------------------
Lo primero que podemos observar que el método retorna un entero y recibe tres parámetros:
----------------------------------------------------------
   public int calcularMayor(int v1,int v2,int v3) {
------------------------------------------------------------
Dentro del método verificamos cuál de los tres parámetros almacena un valor mayor, a este valor lo almacenamos en una variable local llamada "m", al valor almacenado en esta variable lo retornamos al final con un return.
La llamada al método calcularMayor lo hacemos desde dentro del método cargarCalores:
-----------------------------------------------------------------
       mayor=calcularMayor(valor1,valor2,valor3);
------------------------------------------------------------------
Debemos asignar a una variable el valor devuelto por el método calcularMayor. Luego el contenido de la variable mayor lo mostramos:
-----------------------------------------------------------------
       System.out.println("El valor mayor de los tres es:"+mayor);
-----------------------------------------------------------------
La lógica es similar para el cálculo del menor.




----------------------------------------

ATT: LUIS ADRIAN ING. INFORMATICA 2A6

MUY BUENOS CONCEPTOS
Y MUY BUENA RESPUESTA

Metodo: es el procedimiento utilizado para llegar a un fin. Su significado original señala el camino que conduce a un lugar.

Las investigaciones científicas se rigen por el llamado método científico, basado en la observación y la experimentación, la recopilación de datos, la comprobación de las hipótesis de partida.

Existe comúnmente la creencia errónea de que en Java es posible pasar parámetros por referencia, y no es así. Java siempre pasa los parámetros por valor. Esta confusión se da debido a que todas las variables de objeto son referencias a objetos [1]. En el libro “The Java Programming Language” de Ken Arnold y James Gosling (autores de Java), sección 2.6.1., tenemos la siguiente cita: “There is exactly one parameter passing mode in Java – pass by value – and that helps keep things simple.” [2] (Existe un solo modo de paso de parámetros en Java – paso por valor – y eso ayuda a mantener las cosas simples.).

Antes de continuar, vamos a recordar cuáles son las definiciones de paso por valor y paso por referencia: [3]:

Paso por valor significa que cuando un argumento se pasa a una función, la función recibe una copia del valor original. Por lo tanto, si la función modifica el parámetro, sólo la copia cambia y el valor original permanece intacto.

Paso por referencia significa que cuando un argumento se pasa a una función, la función recibe la dirección de memoria del valor original, no la copia del valor. Por lo tanto, si la función modifica el parámetro, el valor original en el código que llamó a la función cambia.

Vamos a valernos de ejemplos para explicar el mecanismo con el que Java pasa parámetros a los métodos.

Tenemos el siguiente programa Java:

1 public class ValorOReferencia {
2
3 private String param1 = new String();
4
5 /** Creates a new instance of PassValueOrReference */
6 public ValorOReferencia(String param1) {
7 this.setParam1(param1);
8 }
9
10 public static void cambiarObjeto(ValorOReferencia objeto) {
11 objeto = new ValorOReferencia("Este es un nuevo objeto.");
12 System.out.println("Luego de \"reasignar\" pass: " + objeto);
13 }
14
15 public static void cambiarParam1(ValorOReferencia objeto) {
16 objeto.setParam1("Este es un nuevo valor para param1.");
17 }
18
19 public static void main(String[] args) {
20 ValorOReferencia pass =
21 new ValorOReferencia("Objeto inicial.");
22 System.out.println("Entender que Java pasa parámetros por valor: ");
23 System.out.println("Antes de modificar pass es: " + pass);
24 ValorOReferencia.cambiarObjeto(pass);
25 System.out.println("De vuelta en main pass es: " + pass);
26 System.out.println("Ahora vamos a cambiar sólo param1:");
28 ValorOReferencia.cambiarParam1(pass);
29 System.out.println("De seguro param 1 ha cambiado: " + pass);
30 System.out.println("Parece difícil, pero no lo es.");
31 }
32
33 public String getParam1() {
34 return param1;
35 }
36
37 public void setParam1(String param1) {
38 this.param1 = param1;
39 }
40
41 public String toString() {
42 return "[param1 = " + this.getParam1() + "]";
43 }
44
45 }

me ayudara mucho en la materia de programación gracias

En la programación orientada a objetos, un método es una subrutina cuyo código es definido en una clase y puede pertenecer tanto a una clase, como es el caso de los métodos de clase o estáticos, como a un objeto, como es el caso de los métodos de instancia



MÉTODOS DE CLASE O STATIC FRENTE A MÉTODOS DE INSTANCIA.

Un método de instancia es el que se invoca siempre sobre una instancia (objeto) de una clase. Por ejemplo p1.getNombre(); siendo p1 un objeto de tipo Persona es un método de instancia: para invocarlo necesitamos una instancia de persona. Un método de clase es aquel que puede ser invocado sin existir una instancia.




Un método de clase se define agregando la palabra clave static antes del tipo en la signatura del método. Ejemplos:

//Ejemplo aprenderaprogramar.com
public static String getNombre () { … }
public static int getNumeroDeDiasDelMes () { … }




Los métodos de clase pueden ser invocados con la notación de punto de estas dos maneras:

//Ejemplo aprenderaprogramar.com
NombreDeLaClase.nombreDelMétodo (parámetros si los hay);
NombreDelObjeto.nombreDelMétodo (parámetros si los hay);

Método: Es la implementación de un algoritmo que representa una operación o función que un objeto realiza. El conjunto de los métodos de un objeto determinan el comportamiento del objeto.

Tipos de métodos
Como ya se mencionó, los métodos de instancia están relacionados con un objeto en particular, mientras que los métodos estáticos o de clase (también denominados métodos compartidos) están asociados a una clase en particular. En una implementación de constructores, siendo estos métodos de instancia especiales llamados automáticamente cuando se crea una instancia de alguna clase. En Java y C++ se distinguen por tener el mismo nombre de la clases a la que están asociados. Lenguajes como Smalltalk no requieren constructores ni destructores.

Los métodos de acceso son un tipo de método normalmente pequeño y simple que se limita a proveer información acerca del estado de un objeto. Aunque introduce una nueva dependencia, la utilización de métodos es preferida a acceder directamente a la información para proveer de una nueva capa de abstracción (programación orientada a objetos). Por ejemplo, si una clase que modela una cuenta bancaria provee de un método de acceso "obtenerBalance()" en versiones posteriores de la clase se podría cambiar el código de dicho método substancialmente sin que el código dependiente de la clase tuviese que ser modificado (un cambio sería necesario siempre que el tipo de dato devuelto por el método cambie). Los métodos de acceso que pueden cambiar el estado de un objeto son llamados, frecuentemente, métodos de actualización ó métodos de mutación; a su vez, los objetos que proveen de dichos métodos son denominados objetos mutables

LUIS ADRIAN escribió:Un método tiene la siguiente sintaxis:
-------------------------------------------------------
public void [nombre del método]() {
 [algoritmo]
}
-----------------------------------------------------
Hay varios tipos de métodos:
Métodos con parámetros.
Un método puede tener parámetros:
--------------------------------------------------------
public void [nombre del método]([parámetros]) {
 [algoritmo]
}
----------------------------------------------------------
Los parámetros los podemos imaginar cómo variables locales al método, pero su valor se inicializa con datos que llegan cuando lo llamamos.
Problema 1:
--------------------------------------
Confeccionar una clase que permita ingresar valores enteros por teclado y nos muestre la tabla de multiplicar de dicho valor. Finalizar el programa al ingresar el -1.
-------------
Programa:
---------------
import java.util.Scanner;
public class TablaMultiplicar {
   public void cargarValor() {
       Scanner teclado=new Scanner(System.in);
       int valor;
       do {
           System.out.print("Ingrese valor:");
           valor=teclado.nextInt();
           if (valor!=-1) {
               calcular(valor);
           }
       } while (valor!=-1);
   }
   
   public void calcular(int v) {
       for(int f=v;f<=v*10;f=f+v) {
           System.out.print(f+"-");
       }
   }
   
   public static void main(String[] ar) {
       TablaMultiplicar tabla;
       tabla=new TablaMultiplicar();
       tabla.cargarValor();
   }
}
----------------------------------------
En esta clase no hemos definido ningún atributo, ya que el objeto de la clase Scanner lo requerimos en un solo método, por ello lo definimos como una variable local.
El método calcular recibe un parámetro de tipo entero, luego lo utilizamos dentro del método para mostrar la tabla de multiplicar de dicho valor, para esto inicializamos la variable f con el valor que llega en el parámetro. Luego de cada ejecución del for incrementamos el contador f con el valor de v.
------------------------------------------------
   public void calcular(int v) {
       for(int f=v;f<=v*10;f=f+v) {
           System.out.print(f+"-");
       }
   }
-----------------------------------------------
Un método puede no tener parámetros como hemos visto en problemas anteriores o puede tener uno o más parámetros (en caso de tener más de un parámetro los mismos se separan por coma)
El método cargarValores no tiene parámetros y tiene por objetivo cargar un valor entero por teclado y llamar al método calcular para que muestre la tabla de multiplicar del valor que le pasamos por teclado:
-------------------------------------------
   public void cargarValor() {
       Scanner teclado=new Scanner(System.in);
       int valor;
       do {
           System.out.print("Ingrese valor:");
           valor=teclado.nextInt();
           if (valor!=-1) {
               calcular(valor);
           }
       } while (valor!=-1);
   }
---------------------------------------------------
Como vemos al método calcular lo llamamos por su nombre y entre paréntesis le pasamos el dato a enviar (debe ser un valor o variable entera)
En este problema en la main solo llamamos al método cargarValor, ya que el método calcular luego es llamado por el método cargarValor:
--------------------------------------------------
   public static void main(String[] ar) {
       TablaMultiplicar tabla;
       tabla=new TablaMultiplicar();
       tabla.cargarValor();
   }
--------------------------------------------------
Métodos que retornan un dato.
Un método puede retornar un dato:
----------------------------------------------------
public [tipo de dato] [nombre del método]([parámetros]) {
 [algoritmo]
 return [tipo de dato]
}
------------------------------------------------------
Cuando un método retorna un dato en vez de indicar la palabra clave void previo al nombre del método indicamos el tipo de dato que retorna. Luego dentro del algoritmo en el momento que queremos que finalice el mismo y retorne el dato empleamos la palabra clave return con el valor respectivo.
------------------------------------------------------------
Problema 2:
-----------------------------------------------------------
Confeccionar una clase que permita ingresar tres valores por teclado. Luego mostrar el mayor y el menor.
Programa:
-----------------------------------------------------------
import java.util.Scanner;
public class MayorMenor {
   public void cargarValores() {
    Scanner teclado=new Scanner(System.in);
       System.out.print("Ingrese primer valor:");
       int valor1=teclado.nextInt();
       System.out.print("Ingrese segundo valor:");
       int valor2=teclado.nextInt();
       System.out.print("Ingrese tercer valor:");
       int valor3=teclado.nextInt();
       int mayor,menor;
       mayor=calcularMayor(valor1,valor2,valor3);
       menor=calcularMenor(valor1,valor2,valor3);
       System.out.println("El valor mayor de los tres es:"+mayor);
       System.out.println("El valor menor de los tres es:"+menor);
   }
   
   public int calcularMayor(int v1,int v2,int v3) {
       int m;
       if(v1>>v2 && v1>v3) {
         m=v1;
       } else {
           if(v2>v3) {
               m=v2;
           } else {
            m=v3;
           }
       }
       return m;
   }
   
   public int calcularMenor(int v1,int v2,int v3) {
       int m;
       if(v1<v2 && v1<v3) {
         m=v1;
       } else {
           if(v2<v3) {
               m=v2;
           } else {
            m=v3;
           }
       }
       return m;
   }
   
   public static void main(String[] ar) {
       MayorMenor maymen=new MayorMenor();
       maymen.cargarValores();
   }
}
---------------------------------------------------
Si vemos la sintaxis que calcula el mayor de tres valores enteros es similar al algoritmo visto en conceptos anteriores:
------------------------------------------------------
   public int calcularMayor(int v1,int v2,int v3) {
       int m;
       if(v1>v2 && v1>v3) {
         m=v1;
       } else {
           if(v2>v3) {
               m=v2;
           } else {
            m=v3;
           }
       }
       return m;
   }
----------------------------------------------------------
Lo primero que podemos observar que el método retorna un entero y recibe tres parámetros:
----------------------------------------------------------
   public int calcularMayor(int v1,int v2,int v3) {
------------------------------------------------------------
Dentro del método verificamos cuál de los tres parámetros almacena un valor mayor, a este valor lo almacenamos en una variable local llamada "m", al valor almacenado en esta variable lo retornamos al final con un return.
La llamada al método calcularMayor lo hacemos desde dentro del método cargarCalores:
-----------------------------------------------------------------
       mayor=calcularMayor(valor1,valor2,valor3);
------------------------------------------------------------------
Debemos asignar a una variable el valor devuelto por el método calcularMayor. Luego el contenido de la variable mayor lo mostramos:
-----------------------------------------------------------------
       System.out.println("El valor mayor de los tres es:"+mayor);
-----------------------------------------------------------------
La lógica es similar para el cálculo del menor.




----------------------------------------

ATT: LUIS ADRIAN ING. INFORMATICA 2A6

Conjunto de instrucciones a las que se les asocia un nombre de modo que si se desea ejecutarlas, sólo basta o reverenciarlas a través de dicho nombre en vez de tener que escribirlas.

Dentro de estas instrucciones es posible acceder con total libertad a la información almacenada en los campos, pertenecientes a la clase dentro de la que el método se ha definido. Por lo que los métodos permiten manipular los datos almacenados en los objetos.

Sintaxis:
()
{
instrucciones;
}

Tipo devuelto: Todo método puede devolver un objeto como resultado de la ejecución de las instrucciones que lo forma, aquí de indica el tipo del dato al que pertenece este objeto.
Si no devuelve nada se indica “void” y si devuelve algo es obligatorio finalizar la ejecución de sus instrucciones con “return ” que indica el objeto a devolverse.

Parámetro: opcionalmente todo método puede recibir en cada llamada una lista de objetos a los que podrá acceder durante la ejecución de sus instrucciones. Aquí se indica cuáles son los tipos de datos de estos objetos y cuál es el nombre con el que harán referencia las instrucciones de método a cada uno de ellos.
Aún que los objetos que puede recibir el método pueden ser diferentes, cada vez que se solicite su ejecución siempre han de ser los mismos tipos y han de seguir el orden establecido en parámetros.

ejemplo:
class persona
{
string nombre;
int edad;
string RFC;
void cumpleaños ()
{
edad ++;
}
}

Sintaxis para llamar a los métodos de un objeto:
.(parámetro)

Parámetro: valores que se desean dar a los parámetros del método al hacer la llamada. Si el método no toma parámetros se deja vacío.

ejemplo: llamado al método cumpleaños de un objeto persona llamado p

p.cumpleaños();

Según el lugar donde son declaradas puede haber dos tipos de variables.

   Globales: las variables permanecen activas durante todo el programa. Se crean al iniciarse éste y se destruyen de la memoria al finalizar. Pueden ser utilizadas en cualquier función.

   Locales: las variables son creadas cuando el programa llega a la función en la que están definidas. Al finalizar la función desaparecen de la memoria.

    Si dos variables, una global y una local, tienen el mismo nombre, la local prevalecerá sobre la global dentro de la función en que ha sido declarada.

    Dos variables locales pueden tener el mismo nombre siempre que estén declaradas en funciones diferentes.


El ámbito de una variable define su alcance de uso, o lo que es lo mismo, en que secciones de código una variable estará disponible. Fuera de este ámbito, una variable no podrá ser accedida (no existe).

En Java tenemos tres tipos de ámbito que pueden aplicar a una variable:

Local
Global
Estático

Veamos un fragmento de código donde aparecen los tres tipos, antes de pasar a explicar con un mínimo de detalle cada uno de ellos:

public class MiClase {
static int variableEstatica;

int variableGlobal;

void miMetodo(int parametro) {
int variableLocal;

// parametro también es local dentro del método
 }
}


ATT: LUIS ADRIAN PINEDA HERRERA 2A6 ING. INFORMATICA

muy buen concepto de métodos me sirvió de mucho

1. PARÁMETROS ACTUALES Y FORMALES
Parámetros actuales: Son los argumentos que aparecen en la llamada a un método. Contienen los valores que se le pasan al método. Un parámetro actual puede ser una variable, un objeto, un valor literal válido, etc.
Parámetros formales: Son los argumentos que aparecen en la cabecera del método. Reciben los valores que se envían en la llamada al método. Se utilizan como variables normales dentro del método.
Los parámetros actuales y los formales deben coincidir en número, orden y tipo. Si el tipo de un parámetro actual no coincide con su correspondiente parámetro formal, el sistema lo convertirá al tipo de este último, siempre que se trate de tipos compatibles. Si no es posible la conversión, el compilador dará los mensajes de error correspondientes.
Si el método devuelve un valor, la llamada al método puede estar incluida en una expresión que recoja el valor devuelto.
2. ÁMBITO DE UNA VARIABLE
El ámbito o alcance de una variable es la zona del programa donde la variable es accesible.
El ámbito lo determina el lugar donde se declara la variable.
En Java las variables se pueden clasificar según su ámbito en:
- Variables miembro de una clase o atributos de una clase
- Variables locales
- Variables de bloque
Variables miembro o atributos de una clase
Son las declaradas dentro de una clase y fuera de cualquier método.
Aunque suelen declararse al principio de la clase, se pueden declarar en cualquier lugar siempre que sea fuera de un método.
Son accesibles en cualquier método de la clase.
Pueden ser inicializadas.
Si no se les asigna un valor inicial, el compilador les asigna uno por defecto:
- 0 para las numéricas
- '\0' para las de tipo char
- null para String y resto de referencias a objetos.
Variables locales
Son las declaradas dentro de un método.
Su ámbito comienza en el punto donde se declara la variable.
Están disponibles desde su declaración hasta el final del método donde se declaran.
No son visibles desde otros métodos.
Distintos métodos de la clase pueden contener variables con el mismo nombre. Se trata de variables distintas.
El nombre de una variable local debe ser único dentro de su ámbito.
Si se declara una variable local con el mismo nombre que una variable miembro de la clase, la variable local oculta a la miembro. La variable miembro queda inaccesible en el ámbito de la variable local con el mismo nombre.
Se crean en memoria cuando se declaran y se destruyen cuando acaba la ejecución del método.
No tienen un valor inicial por defecto. El programador es el encargado de asignarles valores iniciales válidos.
Los parámetros formales son variables locales al método.
Variables de bloque
Son las declaradas dentro de un bloque de instrucciones delimitado por llaves { }.
Su ámbito comienza en el punto donde se declara la variable.
Están disponibles desde su declaración hasta el final del bloque donde se declaran.
No son visibles desde otros bloques.
Distintos bloques pueden contener variables con el mismo nombre. Se trata de variables distintas.
Si un bloque de instrucciones contiene dentro otro bloque de instrucciones, en el bloque interior no se puede declarar una variable con el mismo nombre que otra del bloque exterior.
Se crean en memoria cuando se declaran y se destruyen cuando acaba la ejecución del bloque.
No tienen un valor inicial por defecto. El programador es el encargado de asignarles valores iniciales válidos.

ATENTAMENTE:GERALDINE CASTILLO ,YENIFER GIORNERI OREGON ,LILIANA PRESTEGUI , GERSON DAVID GOMEZ,IRVING ALBARRRAN,ANDRES AVILES,SALOMON ADAME.

Un método tiene la siguiente sintaxis:
-------------------------------------------------------
public void [nombre del método]() {
[algoritmo]
}
-----------------------------------------------------
Hay varios tipos de métodos:
Métodos con parámetros.
Un método puede tener parámetros:
--------------------------------------------------------
public void [nombre del método]([parámetros]) {
[algoritmo]
}
----------------------------------------------------------
Los parámetros los podemos imaginar cómo variables locales al método, pero su valor se inicializa con datos que llegan cuando lo llamamos.
Problema 1:
--------------------------------------
Confeccionar una clase que permita ingresar valores enteros por teclado y nos muestre la tabla de multiplicar de dicho valor. Finalizar el programa al ingresar el -1.
-------------
Programa:
---------------
import java.util.Scanner;
public class TablaMultiplicar {
public void cargarValor() {
Scanner teclado=new Scanner(System.in);
int valor;
do {
System.out.print("Ingrese valor:");
valor=teclado.nextInt();
if (valor!=-1) {
calcular(valor);
}
} while (valor!=-1);
}

public void calcular(int v) {
for(int f=v;f<=v*10;f=f+v) {
System.out.print(f+"-");
}
}

public static void main(String[] ar) {
TablaMultiplicar tabla;
tabla=new TablaMultiplicar();
tabla.cargarValor();
}
}
----------------------------------------
En esta clase no hemos definido ningún atributo, ya que el objeto de la clase Scanner lo requerimos en un solo método, por ello lo definimos como una variable local.
El método calcular recibe un parámetro de tipo entero, luego lo utilizamos dentro del método para mostrar la tabla de multiplicar de dicho valor, para esto inicializamos la variable f con el valor que llega en el parámetro. Luego de cada ejecución del for incrementamos el contador f con el valor de v.
------------------------------------------------
public void calcular(int v) {
for(int f=v;f<=v*10;f=f+v) {
System.out.print(f+"-");
}
}
-----------------------------------------------
Un método puede no tener parámetros como hemos visto en problemas anteriores o puede tener uno o más parámetros (en caso de tener más de un parámetro los mismos se separan por coma)
El método cargarValores no tiene parámetros y tiene por objetivo cargar un valor entero por teclado y llamar al método calcular para que muestre la tabla de multiplicar del valor que le pasamos por teclado:
-------------------------------------------
public void cargarValor() {
Scanner teclado=new Scanner(System.in);
int valor;
do {
System.out.print("Ingrese valor:");
valor=teclado.nextInt();
if (valor!=-1) {
calcular(valor);
}
} while (valor!=-1);
}
---------------------------------------------------
Como vemos al método calcular lo llamamos por su nombre y entre paréntesis le pasamos el dato a enviar (debe ser un valor o variable entera)
En este problema en la main solo llamamos al método cargarValor, ya que el método calcular luego es llamado por el método cargarValor:
--------------------------------------------------
public static void main(String[] ar) {
TablaMultiplicar tabla;
tabla=new TablaMultiplicar();
tabla.cargarValor();
}
--------------------------------------------------
Métodos que retornan un dato.
Un método puede retornar un dato:
----------------------------------------------------
public [tipo de dato] [nombre del método]([parámetros]) {
[algoritmo]
return [tipo de dato]
}
------------------------------------------------------
Cuando un método retorna un dato en vez de indicar la palabra clave void previo al nombre del método indicamos el tipo de dato que retorna. Luego dentro del algoritmo en el momento que queremos que finalice el mismo y retorne el dato empleamos la palabra clave return con el valor respectivo.
------------------------------------------------------------
Problema 2:
-----------------------------------------------------------
Confeccionar una clase que permita ingresar tres valores por teclado. Luego mostrar el mayor y el menor.
Programa:
-----------------------------------------------------------
import java.util.Scanner;
public class MayorMenor {
public void cargarValores() {
Scanner teclado=new Scanner(System.in);
System.out.print("Ingrese primer valor:");
int valor1=teclado.nextInt();
System.out.print("Ingrese segundo valor:");
int valor2=teclado.nextInt();
System.out.print("Ingrese tercer valor:");
int valor3=teclado.nextInt();
int mayor,menor;
mayor=calcularMayor(valor1,valor2,valor3);
menor=calcularMenor(valor1,valor2,valor3);
System.out.println("El valor mayor de los tres es:"+mayor);
System.out.println("El valor menor de los tres es:"+menor);
}

public int calcularMayor(int v1,int v2,int v3) {
int m;
if(v1>>v2 && v1>v3) {
m=v1;
} else {
if(v2>v3) {
m=v2;
} else {
m=v3;
}
}
return m;
}

public int calcularMenor(int v1,int v2,int v3) {
int m;
if(v1<v2 && v1<v3) {
m=v1;
} else {
if(v2<v3) {
m=v2;
} else {
m=v3;
}
}
return m;
}

public static void main(String[] ar) {
MayorMenor maymen=new MayorMenor();
maymen.cargarValores();
}
}
---------------------------------------------------
Si vemos la sintaxis que calcula el mayor de tres valores enteros es similar al algoritmo visto en conceptos anteriores:
------------------------------------------------------
public int calcularMayor(int v1,int v2,int v3) {
int m;
if(v1>v2 && v1>v3) {
m=v1;
} else {
if(v2>v3) {
m=v2;
} else {
m=v3;
}
}
return m;
}
----------------------------------------------------------
Lo primero que podemos observar que el método retorna un entero y recibe tres parámetros:
----------------------------------------------------------
public int calcularMayor(int v1,int v2,int v3) {
------------------------------------------------------------
Dentro del método verificamos cuál de los tres parámetros almacena un valor mayor, a este valor lo almacenamos en una variable local llamada "m", al valor almacenado en esta variable lo retornamos al final con un return.
La llamada al método calcularMayor lo hacemos desde dentro del método cargarCalores:
-----------------------------------------------------------------
mayor=calcularMayor(valor1,valor2,valor3);
------------------------------------------------------------------
Debemos asignar a una variable el valor devuelto por el método calcularMayor. Luego el contenido de la variable mayor lo mostramos:
-----------------------------------------------------------------
System.out.println("El valor mayor de los tres es:"+mayor);
-----------------------------------------------------------------
La lógica es similar para el cálculo del menor.

Gracias por sus respuestas me ayudaron bastante gracias

Tarde compañeros pero seguro ,,,este es mi comentario de la unidad 4 que se
llama:
MÉTODOS
Es un conjunto de código reutilizable del cual se puede hacer un uso continuo
que se encuentra disponible en cualquier momento deseado dentro de la
aplicación.
EJEMPLO DE MÉTODOS
Veamos un ejemplo, primero creemos un método que realice la suma de dos
números, el código sería el siguiente:
private void MetodoSuma(float numero1, float numero2){
float Suma=numero1+numero2;
System.out.println(Suma);
}
Que son los métodos y cómo utilizarlos en java
Java como todo lenguaje de programación orientado a objetos utiliza los
llamados metodos. Acontinuación veremos como se crea un metodo y como
se utilizan.
Se podria decir que existen 2 grandes tipos de metodos, el primer tipo de
metodo son metodos que realizan procesos, puedes realizar cualquier operación
con ellos, sin embargo el proposito es manipular variables existentes. El
segundo tipo de metodos son los que realizan un proceso o calculo, y calculan
una variable especifica, un ejemplo podria ser un metodo para obtener el
valor de una multiplicación.
Estructura de un metodo
Los metodos en java pueden tener parametros, es decir, que un metodo
puede utilizar variables predefinidas para ser utilizadas en sus procesos,
Veamos un ejemplo de como hacer un metodo en el siguiente ejemplo
En este ejemplo vemos un programa normal en el cual se ejecuta un ciclo
while que imprime numeros del 0 al 7, pero ¿es posible hacerlo utilizando un
metodo?
01 package ciclos;
02
03 /**
04 *
05 * @author xymind
06 */
07 public class Main {
08
09 /**
10 * @param args the command line arguments
11 */
12 public static void main(String[] args) {
13
14 int x=0;
15 while(x!=7)
16 {
17 System.out.println("X vale: "+x);
18 x++;
19
20 }
21 }
22
23 }
Ahora utilizaremos este mismo programa pero el ciclo se ejecutara en un
metodo:
01 package ciclos;
02
03 /**
04 *
05 * @author xymind
06 */
07 public class Main {
08
09 /**
10 * @param args the command line arguments
11 */
12 public static void main(String[] args) {
13
14 iniciarCiclo();//aqui estamos ejecutando el metodo escrito en
15 //la parte de abajo, se puede utilizar mas de 1 vez
16 }
17
18 /*Comienza el metodo
19 Este metodo no regresa valores, es un metodo que unicamente
20 realiza un procedimiento, por lo que se declara como "void" seguido del
21 nombre que tendra el metodo*/
22 public void iniciarCiclo(){
23
24 int x=0;
25 while(x!=7)
26 {
27 System.out.println("X vale: "+x);
28 x++;
29
30 }
31 }
32
33 }
Los dos anteriores programas hacen exactamente lo mismo a diferencia de
que el segundo programa esta utilizando un metodo.
En este ultimo ejemplo se mostrara un metodo que regrese un valor, estos
metodos se declaran diferente y siempre deben terminar
con la palabra “return var;” donde “var” es una variable cualquiera del
mismo tipo del metodo. Ejemplo:
Declaramos el metodo:
..//
1 public int obtenerValor(){
2 int x=10;
3 return x;
4 }
//..
Notese que se utiliza “int” en lugar de “void”, lo cual indica que se regresara
una variable del tipo integer o numerico, por lo que dentro del metodo se
declara int x=10; que es precisamente un valor numerico, y se ,ETC...
Lindas vacaciones!!!!

Método
Método (del griego οδός odos, significa "camino o vía") es el procedimiento utilizado para llegar a un fin. Su significado original señala el camino que conduce a un lugar.

Las investigaciones científicas se rigen por el llamado método científico, basado en la observación y la experimentación, la recopilación de datos, la comprobación de las hipótesis de partida.

La idea de método puede hacer referencia a diversos conceptos de varios campos:

Astronomía
Método de Argelander
Biología
Métodos tradicionales de clasificación biológica
Ciencia - Filosofía
Método de investigación
Método científico
Método hipotético deductivo
Metodología
Método de ensayo
Método empírico-analítico
Economía
Método de la ruta crítica
Método justo a tiempo
Filosofía
Discurso del Método
Informática
Método (informática)
Lingüística
Método comparativo
Matemáticas
Método Trachtenberg
Método Gabriel
Métodos de integración
Sexualidad
Método anticonceptivo
Sociología
Método de triangulación
Método sociológico

Métodos en Java
Un método en Java es un conjunto de instrucciones definidas dentro de una clase, que realizan una determinada tarea y a las que podemos invocar mediante un nombre.
 
Algunos métodos que hemos utilizado hasta ahora:
– Math.pow()
– Math.sqrt()
– Character.isDigit()
- System.out.println();

Cuando se llama a un método, la ejecución del programa pasa al método y cuando éste acaba, la ejecución continúa a partir del punto donde se produjo la llamada.

Utilizando métodos:
-  Podemos construir programas modulares.
-  Se consigue la reutilización de código. En lugar de escribir el mismo código repetido cuando se necesite, por ejemplo para validar una fecha, se hace una llamada al método que lo realiza.
En Java un método siempre pertenece a una clase.
Todo programa java tiene un método llamado main. Este método es el punto de entrada al programa y también el punto de salida.
1. ESTRUCTURA GENERAL DE UN MÉTODO JAVA
La estructura general de un método Java es la siguiente:
[especificadores] tipoDevuelto nombreMetodo([lista parámetros]) [throws listaExcepciones]
{
   // instrucciones
  [return valor;]
}
Los elementos que aparecen entre corchetes son opcionales.

especificadores (opcional): determinan el tipo de acceso al método. Se verán en detalle más adelante.

tipoDevuelto: indica el tipo del valor que devuelve el método. En Java es imprescindible que en la declaración de un método, se indique el tipo de dato que ha de devolver. El dato se devuelve mediante la instrucción return. Si el método no devuelve ningún valor este tipo será void.
nombreMetodo: es el nombre que se le da al método. Para crearlo hay que seguir las mismas normas que para crear nombres de variables.
Lista de parámetros (opcional): después del nombre del método y siempre entre paréntesis puede aparecer una lista de parámetros (también llamados argumentos) separados por comas. Estos parámetros son los datos de entrada que recibe el método para operar con ellos. Un método puede recibir cero o más argumentos. Se debe especificar para cada argumento su tipo. Los paréntesis son obligatorios aunque estén vacíos.
throws listaExcepciones (opcional): indica las excepciones que puede generar y manipular el método.
return: se utiliza para devolver un valor. La palabra clave return va seguida de una expresión que será evaluada para saber el valor de retorno. Esta expresión puede ser compleja o puede ser simplemente el nombre de un objeto, una variable de tipo primitivo o una constante.
El tipo del valor de retorno debe coincidir con el tipoDevuelto que se ha indicado en la declaración del método.
Si el método no devuelve nada (tipoDevuelto = void) la instrucción return es opcional.
Un método puede devolver un tipo primitivo, un array, un String o un objeto.
Un método tiene un único punto de inicio, representado por la llave de inicio {. La ejecución de un método termina cuando se llega a la llave final } o cuando se ejecuta la instrucción return.
La instrucción return puede aparecer en cualquier lugar dentro del método, no tiene que estar necesariamente al final.

MUY BUENAS RESPUESTAS COMPAÑEROS ME SIRVIERON MUCHO.

muy buena información