Um método Java é uma combinação de algumas declarações para executar uma operação. Por exemplo, quando você chama o método System.out.println, o sistema realmente executa muitas instruções para produzir informações no console.
Agora você aprenderá como criar seus próprios métodos. Eles podem ter valores de retorno ou nenhum valores de retorno, podem ter parâmetros ou não parâmetros. Os métodos de sobrecarga devem usar o mesmo nome do método e usar métodos abstratos na programação.
Método de criação
Vamos usar o exemplo a seguir para explicar a sintaxe do método:
public static int funcname (int a, int b) {// body}Aqui
Os métodos também contêm procedimentos ou funções.
A definição de um método inclui um cabeçalho de método e um corpo de método. Como mostrado abaixo:
Modificador ReturnType NameofMethod (Lista de parâmetros) {// Método Body}A sintaxe acima inclui
Exemplo
Este é o método max () definido acima, que aceita dois parâmetros num1 e num2 para retornar o valor máximo entre os dois.
/** O snippet retorna o mínimo entre dois números*/public static int minfunção (int n1, int n2) {int min; if (n1> n2) min = n2; else min = n1; retornar min; } Chamada de método
Para usar um método, o método deve ser chamado. Existem duas maneiras de chamar o método, um tem um valor de retorno e o outro não tem valor de retorno.
Chamar um método é muito simples. Quando um programa precisa chamar um método, o programa de controle é transferido para o método chamado. O método retornará duas condições ao chamador:
Pegue o método que retorna nulo como uma declaração de chamada, deixe -me ver o seguinte exemplo:
System.out.println ("wiki.jikexueyuan.com!");O valor de retorno deste método pode ser entendido pelo exemplo a seguir:
int resultado = soma (6, 9);
Exemplo
O exemplo a seguir mostra como definir um método e como chamá -lo:
classe pública ExamplEminNumber {public static void main (string [] args) {int a = 11; int b = 6; int c = minfunção (a, b); System.out.println ("Valor mínimo =" + C); } / ** Retorna o mínimo de dois números* / public static int minfunction (int n1, int n2) {int min; if (n1> n2) min = n2; else min = n1; retornar min; }}Os seguintes resultados serão produzidos
Valor mínimo = 6
Palavra -chave vazio
A palavra -chave vazio nos permite criar um método sem um valor de retorno. Aqui, criamos um método void MethodRankPoints no próximo exemplo. Este método não possui tipo de valor de retorno. Chamar o método void deve declarar MethodRankPoints (255.7); A declaração Java termina com um ponto e vírgula, como mostrado abaixo:
classe pública ExemplineVoid {public static void main (string [] args) {MethodRankPoints (255.7); } public static void MethodRankPoints (pontos duplos) {if (pontos> = 202.5) {System.out.println ("Rank: A1"); } else if (pontos> = 122.4) {System.out.println ("classificação: a2"); } else {System.out.println ("Rank: A3"); }}}Isso produzirá os seguintes resultados:
Classificação: A1
Passe os parâmetros por valores
Os parâmetros devem ser passados ao chamar uma função. E a ordem deles deve ser a mesma que a ordem dos parâmetros quando eles foram criados. Os parâmetros podem ser passados por valores ou referências.
Passar parâmetros através de valores significa chamar o parâmetro do método, passado para o parâmetro através do valor do parâmetro.
Exemplo
O programa a seguir dá um exemplo para mostrar que os parâmetros são passados pelos valores. O valor do parâmetro não será alterado após chamar o método.
classe pública SwappingExample {public static void main (string [] args) {int a = 30; int b = 45; System.out.println ("Antes de trocar, a =" + a + "e b =" + b); // Invoca o método de troca Swapfunção (a, b); System.out.println ("/n ** agora, antes e depois de trocar os valores serão os mesmos aqui **:"); System.out.println ("Após a troca, a =" + a + "e b é" + b); } public static void Swapfunction (int a, int b) {System.out.println ("Antes de trocar (dentro), a =" + a + "b =" + b); // trocar n1 com n2 int c = a; a = b; b = c; System.out.println ("Após trocar (dentro), a =" + a + "b =" + b); }}Isso produzirá os seguintes resultados:
Antes de trocar, a = 30 e b = 45 antes da troca (por dentro), a = 30 b = 45 após trocar (dentro), a = 45 b = 30 ** agora, antes e depois de trocar os valores serão os mesmos aqui **: Depois de trocar, a = 30 e B é 45
Sobrecarga de método
Quando um método tem dois ou mais métodos, seus nomes são iguais, mas os parâmetros são diferentes, é chamado de sobrecarga de método. É diferente de cobertura. A substituição refere -se ao número de métodos com o mesmo nome, tipo e parâmetros.
Vamos considerar o exemplo anterior de encontrar o número inteiro mínimo. Se pedirmos para encontrar o menor número em um tipo de ponto flutuante, precisamos usar a sobrecarga do método para criar dois ou mais métodos com o mesmo nome de função, mas parâmetros diferentes.
Os seguintes exemplos são explicados:
classe pública ExemploOverOrloading {public static void main (string [] args) {int a = 11; int b = 6; duplo C = 7,3; duplo d = 9,4; int resultado1 = minfunção (a, b); // O mesmo nome de função com parâmetros diferentes, resultado duplo2 = minfunção (c, d); System.out.println ("Valor mínimo =" + resultado1); System.out.println ("Valor mínimo =" + resultado2); } // para o número inteiro de estática pública Int minfunction (int n1, int n2) {int min; if (n1> n2) min = n2; else min = n1; retornar min; } // Para duplo duplo minfunção dupla estática (dupla n1, dupla n2) {dupla min; if (n1> n2) min = n2; else min = n1; retornar min; }}Isso produzirá os seguintes resultados:
Valor mínimo = 6 valor mínimo = 7,3
Os métodos de sobrecarga facilitam a leitura do programa. Aqui, os dois métodos têm o mesmo nome, mas parâmetros diferentes. Gera o número mínimo de tipos de pontos inteiros e de ponto flutuante como resultado do programa em execução.
Use parâmetros da linha de comando
Às vezes, você deseja passar os parâmetros antes que o programa seja executado. Isso pode ser alcançado passando os parâmetros da linha de comando para a função principal.
Na linha de comando, quando você deseja executar um arquivo de programa, um parâmetro de linha de comando aparece imediatamente após o nome do arquivo. É muito fácil aceitar parâmetros da linha de comando nos programas Java. Eles são passados para a matriz de caracteres da função principal.
Exemplo
O exemplo a seguir mostra um programa que gera todos os parâmetros da linha de comando:
classe pública CommandLine {public static void main (string args []) {for (int i = 0; i <args.length; i ++) {System.out.println ("args [" + i + "]:" + args [i]); }}}Executar o programa por:
Java CommandLine, esta é uma linha de comando 200 -100
Isso produzirá os seguintes resultados:
args [0]: thisArgs [1]: Isargs [2]: AARGS [3]: Commandargs [4]: lineargs [5]: 200Args [6]: -100
Construtor
Aqui está um exemplo simples de usar construtores:
// um construtor simples.class myclass {int x; // a seguir está o construtor myClass () {x = 10; }}Você pode instanciar um objeto chamando o construtor:
classe pública Considemo {public static void main (string args []) {myclass t1 = new myclass (); MyClass t2 = new myclass (); System.out.println (t1.x + "" + t2.x); }}Normalmente, você precisará usar um construtor para aceitar um ou mais parâmetros. A passagem do parâmetro é a mesma que a passagem do parâmetro do método comum introduzido acima, que é listar a lista de parâmetros após o nome do construtor.
Exemplo
Aqui está um exemplo simples de usar construtores:
// um construtor simples.class myclass {int x; // a seguir está o construtor myClass (int i) {x = i; }}Você pode instanciar um objeto chamando o construtor:
classe pública Considemo {public static void main (string args []) {myclass t1 = new myclass (10); MyClass T2 = new MyClass (20); System.out.println (t1.x + "" + t2.x); }}Isso produzirá os seguintes resultados:
10 20
Parâmetros de comprimento variável
O JDK1.5 pode permitir que você passe parâmetros de comprimento variável do mesmo tipo. Declare usando o seguinte método:
Typename ... ParameterName
Ao declarar um método, você precisa especificar o tipo de parâmetro antes da elipse e pode haver apenas um parâmetro de comprimento variável, e o parâmetro de comprimento da variável deve ser o último de todos os parâmetros.
Exemplo
classe pública varargsdemo {public static void main (string args []) {// Método de chamada com variável args printmax (34, 3, 3, 2, 56.5); printmax (novo duplo [] {1, 2, 3}); } public static void printMax (duplo ... números) {if (números.Length == 0) {System.out.println ("nenhum argumento passou"); retornar; } resultado duplo = números [0]; for (int i = 1; i <números.length; i ++) se (números [i]> resultado) resultado = números [i]; System.out.println ("O valor máximo é" + resultado); }}Isso produzirá os seguintes resultados:
O valor máximo é 56.5, o valor máximo é 3,0
Método Finalize ()
Você pode definir um método que só será chamado antes de ser destruído pelo coletor de lixo. Esse método é chamado de método Finalize (), que também pode ser usado para garantir que um objeto seja limpo.
Por exemplo, você pode usar o finalize () para garantir que o arquivo aberto por um objeto tenha sido fechado.
Para adicionar um finalizador à classe, você só precisa definir o método finalize (). Quando Java deseja reciclar um objeto dessa classe, o método será chamado.
No método finalize (), você especificará algum comportamento que deve ser feito antes que o objeto seja destruído.
O método finalize () é geralmente semelhante ao seguinte:
Void protegido finalize () {// Código de finalização aqui}Aqui, a palavra -chave protegida é garantir que o código fora da classe não possa acessar o método finalize ().
Isso significa que você não pode saber quando o finalize () é executado. Por exemplo, se o seu programa terminar antes que o coletor de lixo ocorra, o método Finalize () não será executado.
Métodos genéricos:
Os métodos genéricos Java são amplamente utilizados quando o método retorna um valor que é um objeto de classe de contêiner.
Lista estática pública <T> Find (classe <t> clazz, string userID) {....}De um modo geral, ao escrever um método genérico Java, o tipo de valor de retorno e pelo menos um tipo de parâmetro devem ser genéricos, e o tipo deve ser o mesmo. Se apenas um dos tipos de valor de retorno ou tipo de parâmetro usar um genérico, o uso desse método genérico será bastante restrito, basicamente ao mesmo nível que se você não usar genéricos.
O seguinte introduz principalmente o uso de dois métodos genéricos Java muito semelhantes e as diferenças entre eles.
O primeiro tipo:
public static <t estende compensar o serviço> t getService (classe <t> clazz) {t service = (t) servicemap.get (clazz.getName ()); if (serviço == null) {service = (t) serviceLocator.getService (clazz.getName ()); servicemap.put (clazz.getName (), serviço); } serviço de retorno; } O segundo tipo:
public static <t> t getService (classe <? Extende o Comumnservice> clazz) {t service = (t) servicemap.get (clazz.getName ()); if (serviço == null) {service = (t) serviceLocator.getService (clazz.getName ()); servicemap.put (clazz.getName (), serviço); } serviço de retorno; } Aqui está a classe em que o método genérico reside:
Classe abstrata pública CommonService {Private Static Hashmap <String, Commonservice> Servicemap = new Hashmap <String, Commonservice> (); // Aqui está a definição de método genérico. . } Esses dois métodos genéricos têm apenas assinaturas de métodos diferentes e os corpos de métodos são exatamente os mesmos. Então, qual é a diferença?
Vamos usá -los e você saberá a diferença.
Use o primeiro método genérico:
public class Main {public static void main (string [] args) {NotiveService NoticeService = comMonservice.getService (NotiveService.class); // Use o primeiro método genérico corretamente sem compilar erros. NotiveService NoticeService = Commonservice.getService (UserService.class); // Se você usar o primeiro método genérico incorretamente, ocorrerá um erro de compilação. }} Use o segundo método genérico:
public class Main {public static void main (string [] args) {NotiveService NoticeService = CommOnservice.getService (NotiveService.class); // Use o segundo método genérico corretamente, não haverá erros de compilação, a lógica está correta e não haverá exceções durante o tempo de execução. NoticeService NoticeService = Commonservice.getService (UserService.class); // Se você usar o segundo método genérico incorretamente, não haverá erros de compilação, mas a lógica estiver incorreta e uma exceção ocorrerá durante o tempo de execução, o que é perigoso! }}Agora eu sei a diferença entre esses dois métodos genéricos extremamente semelhantes?