método java

En los capítulos anteriores usamos frecuentemente System.out.println(), entonces, ¿qué es?

println() es un método (Método), System es una clase del sistema (Clase) y out es un objeto de salida estándar (Objeto). El uso de esta oración es llamar al método println() en el objeto de salida estándar en la clase del sistema System.

Entonces ¿cuál es el método?

Un método Java es una colección de declaraciones que juntas realizan una función.

• Un método es una combinación ordenada de pasos para resolver un tipo de problema.

• Métodos contenidos en clases u objetos.

• Los métodos se crean en el programa y se hace referencia a ellos en otros lugares.

definición del método

Generalmente, definir un método incluye la siguiente sintaxis:

 Nombre del método del tipo de valor de retorno del modificador (nombre del parámetro del tipo de parámetro) {
...
Cuerpo del método...
devolver valor de retorno;
}

Un método contiene un encabezado de método y un cuerpo de método. Aquí están todas las partes de un método:

• Modificadores: los modificadores, que son opcionales, le indican al compilador cómo llamar al método. Define el tipo de acceso para este método.

• Tipo de valor de retorno: los métodos pueden devolver valores. returnValueType es el tipo de datos del valor de retorno del método. Algunos métodos realizan la operación requerida pero no devuelven un valor. En este caso, returnValueType es la palabra clave void .

• Nombre del método: es el nombre real del método. El nombre del método y la lista de parámetros juntos forman la firma del método.

• Tipo de parámetro: el parámetro es como un marcador de posición. Cuando se llama al método, los valores se pasan a los parámetros. Este valor se denomina parámetro o variable real. La lista de parámetros se refiere al tipo de parámetro, el orden y el número de parámetros del método. Los parámetros son opcionales y los métodos no pueden contener parámetros.

• Cuerpo del método: el cuerpo del método contiene declaraciones específicas que definen la función del método.

como:

 publicstaticintage(intcumpleaños){...}

Puede haber múltiples parámetros:

 staticfloatinterest(floatprincipal,intyear){...}

Nota: En algunos otros idiomas, los métodos se refieren a procedimientos y funciones. Un método que devuelve un valor de retorno no nulo se denomina función; un método que devuelve un valor de retorno nulo se denomina procedimiento.

Ejemplo

El siguiente método contiene 2 parámetros num1 y num2 y devuelve el valor máximo de estos dos parámetros.

 /**Devuelve el valor mayor de los datos de dos variables enteras*/
publicstaticintmax(intnum1,intnum2){
interés;
si(núm1>núm2){
resultado=núm1;
}demás{
resultado=núm2;
}
resultado de retorno;
}

llamada al método

Java admite dos formas de llamar a métodos, dependiendo de si el método devuelve un valor.

Cuando un programa llama a un método, el control del programa se transfiere al método llamado. El control se devuelve al programa cuando se ejecuta la declaración de retorno del método llamado o se alcanza el corchete de cierre del cuerpo del método.

Cuando un método devuelve un valor, la llamada al método generalmente se trata como un valor. Por ejemplo:

 intmás grande=max(30,40);

Si el valor de retorno del método es nulo, la llamada al método debe ser una declaración. Por ejemplo, el método println devuelve void. El siguiente llamado es una declaración:

 System.out.println("¡BienvenidoJava!");

Ejemplo

El siguiente ejemplo demuestra cómo definir un método y cómo llamarlo:

 clase públicaPruebaMax{
/**Método principal*/
publicstaticvoidmain(String[]argumentos){
inti=5;
intj=2;
intk=máx(i,j);
System.out.println("El máximo entre"+i+
"y"+j+"es"+k);
}

/**Devuelve el valor mayor de las dos variables enteras*/
publicstaticintmax(intnum1,intnum2){
interés;
si(núm1>núm2){
resultado=núm1;
}demás{
resultado=núm2;
}
resultado de retorno;
}
}

Los resultados de compilación y ejecución del ejemplo anterior son los siguientes:

 El máximo entre 5 y 2 es 5

Este programa contiene el método principal y el método máximo. La JVM llama al método Main. Aparte de eso, el método principal no es diferente de otros métodos.

El encabezado del método principal permanece sin cambios, como se muestra en el ejemplo, con los modificadores public y static, devuelve un valor de tipo void, el nombre del método es main y toma un parámetro de tipo String[]. String[] indica que el parámetro es una matriz de cadenas.

palabra clave vacía

Esta sección explica cómo declarar y llamar a un método nulo.

El siguiente ejemplo declara un método llamado printGrade y lo llama para imprimir la calificación dada.

Ejemplo

 métodopublicclassTestVoid{

publicstaticvoidmain(String[]argumentos){
imprimirCalificación(78.5);
}

publicstaticvoidprintGrade(doble puntuación){
si(puntuación>=90.0){
System.out.println('A');
}
elseif(puntuación>=80.0){
System.out.println('B');
}
elseif(puntuación>=70,0){
System.out.println('C');
}
elseif(puntuación>=60,0){
System.out.println('D');
}
demás{
System.out.println('F');
}
}
}

Los resultados de compilación y ejecución del ejemplo anterior son los siguientes:

 do

El método printGrade aquí es un método de tipo nulo y no devuelve ningún valor.

Una llamada a un método nulo debe ser una declaración. Por lo tanto, se llama como una declaración en la tercera línea del método principal. Como cualquier declaración que termine con punto y coma.

Pasar parámetros por valor

Al llamar a un método, debe proporcionar parámetros y debe proporcionarlos en el orden especificado en la lista de parámetros.

Por ejemplo, el siguiente método imprime un mensaje n veces seguidas:

 publicstaticvoidnPrintln(Stringmessage,intn){
para(inti=0;i<n;i++)
System.out.println(mensaje);
}

Ejemplo

El siguiente ejemplo demuestra el efecto de pasar por valor.

Este programa crea un método que intercambia dos variables.

 clase públicaTestPassByValue{

publicstaticvoidmain(String[]argumentos){
intnúm1=1;
intnúm2=2;

System.out.println("Antes del método de intercambio, num1es"+
núm1+"ynúm2es"+núm2);

//Llama al método de intercambio swap(num1,num2);
System.out.println("Método de intercambio posterior,num1is"+
núm1+"ynúm2es"+núm2);
}
/**Método para intercambiar dos variables*/
publicstaticvoidswap(intn1,intn2){
System.out.println("tDentrodelmétododeintercambio");
System.out.println("ttAntes del intercambion1es"+n1
+"n2es"+n2);
//Intercambia los valores de n1 y n2 inttemp=n1;
n1=n2;
n2=temperatura;

System.out.println("ttDespués del intercambion1es"+n1
+"n2es"+n2);
}
}

Los resultados de compilación y ejecución del ejemplo anterior son los siguientes:

 Antes del método de intercambio, num1is1 y num2is2
Dentro del método de intercambio
Antes del intercambion1is1n2is2
Después del intercambion1is2n2is1
Método posterior al intercambio, num1is1 y num2is2

Llame al método de intercambio pasando dos parámetros. Curiosamente, los valores de los parámetros reales no cambian después de que se llama al método.

Sobrecarga de métodos

El método max utilizado anteriormente solo se aplica a datos de tipo int. Pero, ¿qué sucede si desea obtener el valor máximo de dos tipos de datos de punto flotante?

La solución es crear otro método con el mismo nombre pero con diferentes parámetros, como se muestra en el siguiente código:

 publicstaticdoublemax(doblenum1,doublenum2){
si(núm1>núm2){
número de retorno1;
}demás{
número de retorno2;
}
}

Si pasa un parámetro int al llamar al método max, se llamará al método max del parámetro int;

Si se pasa un parámetro doble, se llamará al cuerpo del método máximo del tipo doble. Esto se denomina sobrecarga de método;

Es decir, dos métodos de una clase tienen el mismo nombre, pero listas de parámetros diferentes.

El compilador de Java determina qué método se debe llamar en función de la firma del método.

La sobrecarga de métodos puede hacer que el programa sea más claro y fácil de leer. Los métodos que realizan tareas estrechamente relacionadas deben utilizar el mismo nombre.

Los métodos sobrecargados deben tener listas de parámetros diferentes. No puede sobrecargar métodos basados ​​únicamente en modificadores o tipos de retorno.

alcance variable

El alcance de una variable es la parte del programa desde la que se puede hacer referencia a la variable.

Las variables definidas dentro de un método se denominan variables locales.

El alcance de una variable local comienza desde su declaración y termina al final del bloque que la contiene.

Las variables locales deben declararse antes de poder usarse.

El alcance del parámetro de un método cubre todo el método. El parámetro es en realidad una variable local.

Las variables declaradas en la parte de inicialización del bucle for tienen alcance durante todo el bucle.

Pero el ámbito de aplicación de la variable declarada en el cuerpo del bucle es desde su declaración hasta el final del cuerpo del bucle. Contiene declaraciones de variables como se muestra a continuación:

Puede declarar una variable local con el mismo nombre varias veces dentro de un método, en diferentes bloques no anidados, pero no puede declarar una variable local dos veces dentro de un bloque anidado.

Uso de parámetros de línea de comando

A veces desea pasar mensajes a un programa mientras se está ejecutando. Esto se logra pasando argumentos de la línea de comando a la función main().

Los parámetros de la línea de comando son la información que sigue inmediatamente al nombre del programa al ejecutar el programa.

Ejemplo

El siguiente programa imprime todos los argumentos de la línea de comando:

 publicclassCommandLine{
publicstaticvoidmain(Stringargs[]){
for(inti=0;i<args.length;i++){
System.out.println("args ["+i+"]:"+args[i]);
}
}
}

Ejecute el programa como se muestra a continuación:

 javaCommandLinethisiscommandline200-100

Los resultados de ejecución son los siguientes:

 argumentos [0]: esto
argumentos[1]:es
argumentos[2]:a
argumentos [3]: comando
argumentos [4]: ​​línea
argumentos[5]:200
argumentos[6]:-100

Constructor

Cuando se crea un objeto, se utilizan constructores para inicializar el objeto. El constructor tiene el mismo nombre que la clase a la que pertenece, pero no tiene valor de retorno.

Los constructores se utilizan normalmente para asignar valores iniciales a variables de instancia de una clase o para realizar otros pasos necesarios para crear un objeto completo.

Independientemente de si personaliza el constructor o no, todas las clases tienen constructores porque Java proporciona automáticamente un constructor predeterminado que inicializa todos los miembros en 0.

Una vez que define su propio constructor, el constructor predeterminado deja de ser válido.

Ejemplo

Aquí hay un ejemplo usando métodos constructores:

 //Un constructor simple static classMyClass{
intx;

//El siguiente es el constructor MyClass(){
x=10;
}
}

Puedes inicializar un objeto llamando al constructor de esta manera:

 publicclassConsDemo{
publicstaticvoidmain(Stringargs[]){
MiClaset1=nuevaMiClase();
MiClaset2=nuevaMiClase();
System.out.println(t1.x+""+t2.x);
}
}

La mayoría de las veces se necesita un constructor con parámetros.

Ejemplo

Aquí hay un ejemplo usando métodos constructores:

 //Un constructor simple classMyClass{
intx;

//El siguiente es el constructor MyClass(inti){
x=yo;
}
}

Puedes inicializar un objeto llamando al constructor de esta manera:

 publicclassConsDemo{
publicstaticvoidmain(Stringargs[]){
MiClase1=nuevaMiClase(10);
MiClaset2=newMiClase(20);
System.out.println(t1.x+""+t2.x);
}
}

Los resultados de ejecución son los siguientes:

 1020

Parámetros variables

A partir de JDK 1.5, Java admite pasar parámetros variables del mismo tipo a un método.

La declaración de los parámetros variables del método se ve así:

 tipoNombre...nombreParámetro

En una declaración de método, agregue puntos suspensivos (...) después de especificar el tipo de parámetro.

Solo se puede especificar un parámetro variable en un método y debe ser el último parámetro del método. Todos los parámetros ordinarios deben declararse antes.

Ejemplo

 publicclassVarargsDemo{

publicstaticvoidmain(Stringargs[]){
// Llama al método de parámetro variable printMax(34,3,3,2,56.5);
printMax(nuevodoble[]{1,2,3});
}

publicstaticvoidprintMax(doble...números){
si(números.longitud==0){
System.out.println("No se aprobó ningún argumento");
devolver;
}

resultado doble=números[0];

for(inti=1;i<números.longitud;i++)
if(números[i]>resultado){
resultado=números[i];
}
System.out.println("Elvalormaxes"+resultado);
}
}

Los resultados de compilación y ejecución del ejemplo anterior son los siguientes:

 El valor máximo es 56,5
El valor máximo es 3.0

método finalizar()

Java permite la definición de dicho método, que se llama antes de que el recolector de basura destruya (recicle) el objeto. Este método se llama finalize (), que se utiliza para borrar el objeto reciclado.

Por ejemplo, puede utilizar finalize() para asegurarse de que un archivo abierto por un objeto esté cerrado.

En el método finalize(), debe especificar las operaciones que se realizarán cuando se destruya el objeto.

El formato general de finalizar() es:

 protegidovoidfinalize()
{
//Código de terminal aquí}

La palabra clave protected es un calificador que garantiza que el método finalize() no será llamado por código fuera de la clase.

Por supuesto, la JVM puede completar automáticamente el reciclaje de la memoria de Java. Si lo usa manualmente, puede usar el método anterior.

Ejemplo

 publicclassFinalizationDemo{
publicstaticvoidmain(String[]argumentos){
Pastelc1=nuevoPastel(1);
Pastelc2=nuevoPastel(2);
Pastelc3=nuevoPastel(3);

c2=c3=nulo;
System.gc();//Llamar al recolector de basura de Java}
}

claseCakeextendsObject{
privadointid;
torta pública(intid){
this.id=id;
System.out.println("CakeObject"+id+"iscreated");
}

protectedvoidfinalize()throwsjava.lang.Throwable{
super.finalizar();
System.out.println("CakeObject"+id+"isdisposed");
}
}

Al ejecutar el código anterior, los resultados de salida son los siguientes:

 C:1>javaFinalizaciónDemostración
CakeObject1iscreated
Se crea CakeObject2
Se crea CakeObject3
CakeObject3 está eliminado
CakeObject2 está eliminado