I Java , den metod är en samling påståenden som utför en specifik uppgift eller operation. Det används ofta eftersom det ger återanvändning av kod som skriver en gång och använder den många gånger. Det ger också enkel modifiering. Varje metod har sitt eget namn som det är kallad . När kompilatorn läser metodnamnet anropas metoden och utför den angivna uppgiften. I det här avsnittet kommer vi att lära oss hur man ringer fördefinierade, användardefinierade, statiska, och abstrakt metoder i Java .
Anropar statisk metod i Java
I Java , en statisk metod är en metod som anropas eller anropas utan att skapa objektet för klassen där metoden är definierad. Alla metoder som har statiskt nyckelord före metodnamnet är kända som statiska metoder . Vi kan också skapa en statisk metod genom att använda statisk nyckelord före metodnamnet. Vi kan kalla en statisk metod genom att använda Klassnamn.metodNamn .
Det bästa exemplet på den statiska metoden är main() metod. Det kallas utan att skapa objektet.
hur många städer usa
I följande program har vi kallat den statiska metoden för Math-klassen, som heter min() som returnerar minimivärdet av två tal.
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); } } Produktion:
Minimum number is 23
Anropa den fördefinierade metoden i Java
I Java är fördefinierade metoder de metoder som redan är definierade i klasserna. När vi krävde någon fördefinierad metod kallar vi bara metoden för dess namn.
I följande exempel har vi använt en metod som heter hash-kod() av klassen Objekt . Att anropa den fördefinierade metoden hash-kod() , vi har skapat ett objekt obj av klassen Object eftersom det är metoden för klassen Object. Genom att använda objektet har vi kallat hash-kod() metod som returnerar en hash-kod värdet för objektet.
PredefinedMethodCallExample.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); } } Produktion:
Hash Code of the object is: 2036368507
Anropar användardefinierad metod i Java
För att anropa en användardefinierad metod skapar vi först en metod och anropar den sedan. En metod måste skapas i klassen med namnet på metoden, följt av parenteser (). Metoddefinitionen består av en metodhuvud och metodkropp.
Vi kan anropa en metod genom att använda följande:
flyta till snöre
method_name(); //non static method calling
Om metoden är en statisk metod använder vi följande:
obj.method_name(); //static method calling
Där obj är objektet för klassen.
I följande exempel har vi skapat två användardefinierade metoder med namnet showMessage() och displayMessage() . De showMessage() metod är en statisk metod och displayMessage() Metoden är en icke-statisk metod.
Observera att vi har kallat showMessage() metoden direkt, utan att använda objektet. Medan displayMessage() metod anropas genom att använda klassens objekt.
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 } } Produktion:
The static method invoked. Non-static method invoked.
En klass kan innehålla två eller flera metoder med samma namn. Nu uppstår en fråga om hur vi kan kalla två metoder med samma namn.
När en klass har två eller flera metoder med samma namn särskiljs den av endera returtyp eller typer av parameter eller antal parametrar . Detta koncept kallas metodöverbelastning . Till exempel:
int sum(int x, int y); double sum(double x, double y);
Ovanstående två metoder har samma namn belopp() men båda är olika. Den första sum()-metoden returnerar ett int-värde och analyserar två heltal x och y som parametrar. Medan den andra sum()-metoden returnerar ett dubbelt värde och analyserar två dubbla värden a och y som parametrar.
Låt oss skapa ett program som överbelastas sub() metod.
MethodOverloadingExample.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); } } Produktion:
subtraction of integer values: 22 subtraction of double values: 13.170000000000002
Anropa abstrakt metod i Java
En abstrakt metod är en metod som deklareras med en abstrakt nyckelord. Den abstrakta metoden har bara en metoddeklaration. Bollen för den abstrakta metoden definierad i den andra klassen. den abstrakta metoden måste deklareras i abstrakt klass . Vi kan ställa in synlighet av abstrakta metoder som privata eller offentliga. Vi kan inte förklara en abstrakt metod som slutgiltig eftersom den bryter mot fördelen med den abstrakta metoden.
Själva implementeringen av den abstrakta metoden måste ske i barnets klass. Vi kan definiera en abstrakt metod enligt följande:
exekvera skriptskal
abstract public void findArea();
Låt oss skapa ett exempel på att kalla den abstrakta metoden.
I följande exempel har vi skapat en klass med namnet AbstractMethodExample och förklara det som abstrakt. I den här klassen har vi deklarerat en abstrakt metod som heter show() . Efter det har vi skapat en annan klass som heter AbstractMethodCalling som förlänger AbstractMethodExample klass. I den här klassen har vi implementerat den abstrakta metoden.
För att anropa den abstrakta metoden show() har vi skapat en instans av den överordnade klassen och anropat den abstrakta metoden.
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(); } } Produktion:
The abstract method called.