Em Java , o método é uma coleção de instruções que executa uma tarefa ou operação específica. É amplamente utilizado porque fornece capacidade de reutilização de código, significa escrever uma vez e usá-lo muitas vezes. Ele também fornece modificação fácil. Cada método tem seu próprio nome pelo qual é chamado . Quando o compilador lê o nome do método, o método é chamado e executa a tarefa especificada. Nesta seção, aprenderemos como chamar predefinidos, definidos pelo usuário, estáticos, e abstrato métodos em Java .
Chamando método estático em Java
Em Java , um método estático é um método que é invocado ou chamado sem criar o objeto da classe na qual o método está definido. Todos os métodos que possuem palavra-chave estática antes do nome do método são conhecidos como métodos estáticos . Também podemos criar um método estático usando o estático palavra-chave antes do nome do método. Podemos chamar um método estático usando o NomeDaClasse.nomeDoMetodo .
O melhor exemplo do método estático é o principal() método. É chamado sem criar o objeto.
linux qual comando
No programa a seguir, chamamos o método estático da classe Math, denominado min() que retorna o valor mínimo de dois números.
StaticMethodCallExample.java
import java.util.*; public class StaticMethodCallExample { public static void main(String args[]) { int a; //calling static method of the Math class a=Math.min(23,98); System.out.println('Minimum number is: ' + a); } } Saída:
Minimum number is 23
Chamando o método pré-definido em Java
Em Java, métodos predefinidos são os métodos que já estão definidos nas classes. Quando solicitamos qualquer método predefinido, apenas chamamos o método pelo seu nome.
No exemplo a seguir, usamos um método chamado código hash() da classe Objeto . Para chamar o método predefinido código hash() , criamos um objeto obj da classe Object porque é o método da classe Object. Usando o objeto que chamamos de código hash() método que retorna um código hash valor para o objeto.
PredefinidoMethodCallExample.java
public class PredefinedMethodCallExample { public static void main(String[] args) { int a; Object obj=new Object(); a=obj.hashCode(); System.out.println('Hash Code of the object is: '+a); } } Saída:
Hash Code of the object is: 2036368507
Chamando método definido pelo usuário em Java
Para chamar um método definido pelo usuário, primeiro criamos um método e depois o chamamos. Deve ser criado um método na classe com o nome do método, seguido de parênteses (). A definição do método consiste em um cabeçalho e um corpo de método.
Podemos chamar um método usando o seguinte:
method_name(); //non static method calling
Se o método for um método estático, usamos o seguinte:
o que é hashset java
obj.method_name(); //static method calling
Onde obj é o objeto da classe.
No exemplo a seguir, criamos dois métodos definidos pelo usuário chamados Mostrar mensagem() e displayMessage() . O Mostrar mensagem() método é um método estático e displayMessage() método é um método não estático.
Observe que chamamos o Mostrar mensagem() método diretamente, sem usar o objeto. Enquanto o displayMessage() O método é chamado usando o objeto da classe.
MethodCallExample.java
public class MethodCallExample { //user-defined static method static void showMessage() { System.out.println('The static method invoked.'); } //user-defined non-static method void displayMessage() { System.out.println('Non-static method invoked.'); } public static void main(String[] args) { //calling static method without using the object showMessage(); //called method //creating an object of the class MethodCallExample me=new MethodCallExample(); //calling non-static method me.displayMessage(); //called method } } Saída:
The static method invoked. Non-static method invoked.
Uma classe pode conter dois ou mais métodos com o mesmo nome. Agora surge uma questão de como podemos chamar dois métodos com o mesmo nome.
Quando uma classe possui dois ou mais métodos com o mesmo nome, ela é diferenciada por tipo de retorno ou tipos de parâmetro ou número de parâmetros . Este conceito é denominado sobrecarga de método . Por exemplo:
int sum(int x, int y); double sum(double x, double y);
Os dois métodos acima têm o mesmo nome soma() mas ambos são diferentes. O primeiro método sum() retorna um valor int e analisa dois inteiros xey como parâmetros. Enquanto o segundo método sum() retorna um valor duplo e analisa dois valores duplos aey como parâmetros.
Vamos criar um programa que sobrecarregue sub() método.
MétodoOverloadingExample.java
public class MethodOverloadingExample { static int sub(int x, int y) { return x - y; } static double sub(double x, double y) { return x - y; } public static void main(String[] args) { int a = sub(45, 23); double b = sub(23.67,10.5); System.out.println('subtraction of integer values: ' +a); System.out.println('subtraction of double values: ' +b); } } Saída:
subtraction of integer values: 22 subtraction of double values: 13.170000000000002
Chamando método abstrato em Java
Um método abstrato é um método declarado com um abstrato palavra-chave. O método abstrato possui apenas uma declaração de método. O corpo do método abstrato definido na outra classe. o método abstrato deve ser declarado no classe abstrata . Podemos definir a visibilidade dos métodos abstratos como privados ou públicos. Não podemos declarar um método abstrato como final porque isso viola a vantagem do método abstrato.
A implementação real do método abstrato deve estar na classe da criança. Podemos definir um método abstrato da seguinte forma:
são exemplos de modelos
abstract public void findArea();
Vamos criar um exemplo de chamada do método abstrato.
No exemplo a seguir, criamos uma classe com o nome AbstratoMétodoExemplo e declare-o como abstrato. Nesta classe, declaramos um método abstrato chamado mostrar() . Depois disso, criamos outra classe chamada AbstractMethodCalling que estende o AbstratoMétodoExemplo aula. Nesta classe, implementamos o método abstrato.
Para chamar o método abstrato show(), criamos uma instância da classe pai e invocamos o método abstrato.
AbstractMethodCalling.java
//abstract class abstract class AbstractMethodExample { //abstract method declaration abstract void show(); } public class AbstractMethodCalling extends AbstractMethodExample { //abstract method implementation void show() { System.out.println('The abstract method called.'); } public static void main(String args[]) { AbstractMethodExample obj = new AbstractMethodCalling(); //calling abstract method obj.show(); } } Saída:
The abstract method called.