Un método Java es una combinación de algunas declaraciones para realizar una operación. Por ejemplo, cuando llame al método System.out.println, el sistema realmente ejecutará muchas declaraciones para obtener información en la consola.
Ahora aprenderá a crear sus propios métodos. Pueden tener valores de retorno o no valores de retorno, pueden tener parámetros o no parámetros. Los métodos de sobrecarga deben usar el mismo nombre del método y usar métodos abstractos en la programación.
Método de creación
Usemos el siguiente ejemplo para explicar la sintaxis del método:
public static int Funcname (int a, int b) {// cuerpo}Aquí
Los métodos también contienen procedimientos o funciones.
La definición de un método incluye un encabezado de método y un cuerpo de método. Como se muestra a continuación:
modificador returnType nameOfMethod (Lista de parámetros) {// Método Cuerpo}La sintaxis anterior incluye
Ejemplo
Este es el método max () definido anteriormente, que acepta dos parámetros num1 y num2 para devolver el valor máximo entre los dos.
/** El fragmento devuelve el mínimo entre dos números*/public static int minfunction (int n1, int n2) {int min; if (n1> n2) min = n2; más min = n1; regresar min; } Llamada de método
Para usar un método, se debe llamar al método. Hay dos formas de llamar al método, uno tiene un valor de retorno y el otro no tiene valor de retorno.
Llamar a un método es muy simple. Cuando un programa necesita llamar a un método, el programa de control se transfiere al método llamado. El método devolverá dos condiciones a la persona que llama:
Tome el método que devuelve el vacío como una declaración de llamada, permítanme ver el siguiente ejemplo:
System.out.println ("wiki.jikexueyuan.com!");El valor de retorno de este método puede entenderse mediante el siguiente ejemplo:
int resultado = sum (6, 9);
Ejemplo
El siguiente ejemplo muestra cómo definir un método y cómo llamarlo:
clase pública EjemplMinnumber {public static void main (string [] args) {int a = 11; int b = 6; int c = minfunction (a, b); System.out.println ("valor mínimo =" + c); } / ** Devuelve el mínimo de dos números* / public static int minfunction (int n1, int n2) {int min; if (n1> n2) min = n2; más min = n1; regresar min; }}Se producirán los siguientes resultados
Valor mínimo = 6
Palabra clave vacío
La palabra clave void nos permite crear un método sin un valor de retorno. Aquí creamos un método Void MethodRankPoints en el siguiente ejemplo. Este método no tiene tipo de valor de retorno. Llamar al método vacío debe declarar MethodRankPoints (255.7); La declaración de Java termina con un punto y coma, como se muestra a continuación:
clase pública EjemploVoid {public static void main (String [] args) {MethodRankPoints (255.7); } public static void MethodRankPoints (puntos dobles) {if (puntos> = 202.5) {system.out.println ("rango: a1"); } else if (puntos> = 122.4) {system.out.println ("rango: a2"); } else {System.out.println ("Rank: A3"); }}}Esto producirá los siguientes resultados:
Rango: A1
Pasar parámetros por valores
Los parámetros deben pasarse al llamar a una función. Y su orden debe ser el mismo que el orden de los parámetros cuando fueron creados. Los parámetros pueden pasar por valores o referencias.
Pasar los parámetros a través de valores significa llamar al parámetro del método, pasada al parámetro a través del valor del parámetro.
Ejemplo
El siguiente programa da un ejemplo para mostrar que los parámetros se pasan por valores. El valor del parámetro no cambiará después de llamar al método.
clase pública intercambiando EXample {public static void main (string [] args) {int a = 30; int b = 45; System.out.println ("Antes de intercambiar, a =" + a + "y b =" + b); // Invocar el método de intercambio de intercambio de intercambio (a, b); System.out.println ("/n ** ahora, antes y después de los valores de intercambio será igual aquí **:"); System.out.println ("Después de intercambiar, a =" + a + "y b es" + b); } public static void swapFunction (int a, int b) {system.out.println ("antes de intercambiar (adentro), a =" + a + "b =" + b); // intercambio N1 con n2 int c = a; a = b; b = c; System.out.println ("Después de intercambiar (adentro), a =" + a + "b =" + b); }}Esto producirá los siguientes resultados:
Antes de intercambiar, a = 30 y b = 45 antes de intercambiar (por dentro), a = 30 b = 45 después de intercambiar (por dentro), a = 45 b = 30 ** ahora, antes y después de intercambiar los valores serán mismos aquí **: después de intercambiar, a = 30 y b es 45
Sobrecarga de métodos
Cuando un método tiene dos o más métodos, sus nombres son los mismos, pero los parámetros son diferentes, se denomina sobrecarga del método. Es diferente de la cubierta. La anulación se refiere al número de métodos con el mismo nombre, tipo y parámetros.
Consideremos el ejemplo anterior de encontrar el número de entero mínimo. Si pedimos encontrar el número más pequeño en un tipo de punto flotante, debemos usar la sobrecarga del método para crear dos o más métodos con el mismo nombre de función pero diferentes parámetros.
Se explican los siguientes ejemplos:
clase pública Ejemplo de carga de carga {public static void main (string [] args) {int a = 11; int b = 6; doble c = 7.3; doble d = 9.4; int resultado1 = minfunction (a, b); // el mismo nombre de función con diferentes parámetros double resultado2 = minfunction (c, d); System.out.println ("Valor mínimo =" + resultado1); System.out.println ("Valor mínimo =" + resultado2); } // para Integer public static int minFunction (int n1, int n2) {int min; if (n1> n2) min = n2; más min = n1; regresar min; } // para doble minfunción de doble pública estática (doble n1, doble n2) {doble min; if (n1> n2) min = n2; más min = n1; regresar min; }}Esto producirá los siguientes resultados:
Valor mínimo = 6 Valor mínimo = 7.3
Los métodos de sobrecarga hacen que el programa sea fácil de leer. Aquí, los dos métodos tienen el mismo nombre pero diferentes parámetros. Genera el número mínimo de tipos enteros y de puntos flotantes como resultado del programa en ejecución.
Usar parámetros de línea de comando
A veces desea pasar parámetros antes de que se ejecute el programa. Esto se puede lograr pasando los parámetros de línea de comandos a la función principal.
En la línea de comando, cuando desea ejecutar un archivo de programa, un parámetro de línea de comando aparece inmediatamente después del nombre del archivo. Es muy fácil aceptar parámetros de línea de comandos en programas Java. Se pasan a la matriz de caracteres de la función principal.
Ejemplo
El siguiente ejemplo muestra un programa que genera todos los parámetros de línea de comando:
Public Class Commandline {public static void main (string args []) {for (int i = 0; i <args.length; i ++) {system.out.println ("args [" + i + "]:" + args [i]); }}}Ejecutar el programa por:
línea de comandos de Java Esta es una línea de comando 200-100
Esto producirá los siguientes resultados:
Args [0]: thisargs [1]: isargs [2]: aargs [3]: commandargs [4]: linealgs [5]: 200args [6]: -100
Constructor
Aquí hay un ejemplo simple de usar constructores:
// un simple constructor.class myclass {int x; // El siguiente es el constructor myClass () {x = 10; }}Puede instanciar un objeto llamando al constructor:
Public Class Consdemo {public static void main (String args []) {myclass t1 = new myClass (); MyClass t2 = new myClass (); System.out.println (t1.x + "" + t2.x); }}Por lo general, deberá usar un constructor para aceptar uno o más parámetros. El paso del parámetro es el mismo que el paso del parámetro del método ordinario introducido anteriormente, que es enumerar la lista de parámetros después del nombre del constructor.
Ejemplo
Aquí hay un ejemplo simple de usar constructores:
// un simple constructor.class myclass {int x; // El siguiente es el constructor myclass (int i) {x = i; }}Puede instanciar un objeto llamando al constructor:
Public Class Consdemo {public static void main (string args []) {myclass t1 = new myClass (10); MyClass t2 = new MyClass (20); System.out.println (t1.x + "" + t2.x); }}Esto producirá los siguientes resultados:
10 20
Parámetros de longitud variable
JDK1.5 puede permitirle pasar parámetros de longitud variable del mismo tipo. Declararlo utilizando el siguiente método:
Typename ... Nombre de parámetro
Al declarar un método, debe especificar el tipo de parámetro antes de los elipsis, y solo puede haber un parámetro de longitud de variable, y el parámetro de longitud variable debe ser el último de todos los parámetros.
Ejemplo
public class varargsdemo {public static void main (string args []) {// método de llamada con args variable printmax (34, 3, 3, 2, 56.5); printmax (nuevo doble [] {1, 2, 3}); } public static void printMax (doble ... números) {if (números.length == 0) {system.out.println ("No se aprobó el argumento"); devolver; } doble resultado = números [0]; para (int i = 1; i <numbers.length; i ++) if (números [i]> resultado) resultado = números [i]; System.out.println ("El valor máximo es" + resultado); }}Esto producirá los siguientes resultados:
El valor máximo es 56.5 El valor máximo es 3.0
Método Finalize ()
Puede definir un método que solo se llamará antes de ser destruido por el recolector de basura. Este método se llama método Finalize (), que también se puede utilizar para garantizar que se limpie un objeto.
Por ejemplo, puede usar Finalize () para asegurarse de que el archivo abierto por un objeto haya sido cerrado.
Para agregar un finalizador a la clase, solo necesita definir el método Finalize (). Cuando Java quiere reciclar un objeto de esta clase, se llamará al método.
En el método Finalize (), especificará algún comportamiento que debe hacerse antes de que el objeto sea destruido.
El método Finalize () es generalmente similar al siguiente:
protegido void finalize () {// código de finalización aquí}Aquí, la palabra clave protegida es asegurarse de que el código fuera de la clase no pueda acceder al método Finalize ().
Esto significa que no puede saber cuándo se ejecuta Finalize (). Por ejemplo, si su programa termina antes de que ocurra el recolector de basura, no se ejecutará el método final ().
Métodos genéricos:
Los métodos genéricos Java se usan ampliamente cuando el método devuelve un valor que es un objeto de clase contenedor.
Lista estática pública <T> find (class <t> clazz, string userId) {....}En términos generales, al escribir un método genérico Java, el tipo de valor de retorno y al menos un tipo de parámetro deben ser genéricos, y el tipo debe ser el mismo. Si solo uno del tipo de valor de retorno o tipo de parámetro usa un genérico, el uso de este método genérico estará muy restringido, básicamente al mismo nivel que si no usara genéricos.
Lo siguiente introduce principalmente el uso de dos métodos genéricos Java muy similares y las diferencias entre ellos.
El primer tipo:
public static <t extiende CommonService> t if (servicio == null) {servicio = (t) ServiceLocator.getService (clazz.getName ()); serviceMap.put (clazz.getName (), servicio); } servicio de retorno; } El segundo tipo:
public static <t> t getService (class <? extiende commonservice> clazz) {t servicio = (t) serviceMap.get (clazz.getName ()); if (servicio == null) {servicio = (t) ServiceLocator.getService (clazz.getName ()); serviceMap.put (clazz.getName (), servicio); } servicio de retorno; } Aquí está la clase donde reside el método genérico:
Public Abstract Class CommonService {private static hashmap <String, CommonService> ServiceMap = new Hashmap <String, CommonService> (); // Aquí está la definición de método genérico. . } Estos dos métodos genéricos solo tienen firmas de diferentes métodos y los cuerpos de método son exactamente los mismos. Entonces, ¿cuál es la diferencia?
Usémoslos y sabrá la diferencia.
Use el primer método genérico:
Public Class Main {public static void main (String [] args) {noticeservice noticeservice = commonService.getService (noticeservice.class); // Use el primer método genérico correctamente sin compilar errores. NoticesService NoticesService = CommonService.getService (Userservice.class); // Si usa el primer método genérico incorrectamente, se producirá un error de compilación. }} Use el segundo método genérico:
Public Class Main {public static void main (String [] args) {noticesService noticeservice = commonService.getService (noticesService.class); // use el segundo método genérico correctamente, no habrá errores de compilación, la lógica es correcta, y no habrá excepciones durante el tiempo de ejecución. NoticesService NoticesService = CommonService.getService (Userservice.class); // Si usa el segundo método genérico incorrectamente, ¡no habrá errores de compilación, pero la lógica es incorrecta y se producirá una excepción durante el tiempo de ejecución, lo cual es peligroso! }}¿Ahora sé la diferencia entre estos dos métodos genéricos extremadamente similares?