Java Methods Onder de Knie: Creëren, Aanroepen en Abstraktie

• modifier – Het definieert het toegangstype van de methode en het is optioneel om te gebruiken.

• returnType – Methode kan een waarde retourneren.

• naamVanMethode – Dit is de methode-naam. De methode-handtekening bestaat uit de methode-naam en de parameterlijst.

• Parameter Lijst – De lijst van parameters, het is het type, de volgorde, en het aantal parameters van een methode. Deze zijn optioneel, een methode kan nul parameters bevatten.

• methode body – De methode-body definieert wat de methode doet met de statements.

Voorbeeld

Hier is de broncode van de bovendefinieerde methode genaamd min(). Deze methode neemt twee parameters num1 en num2 en retourneert het maximum tussen de twee –

/** het codefragment retourneert het minimum tussen twee getallen */
public static int minFunction(int n1, int n2) {
    int min;
    if (n1 > n2)
        min = n2;
    else
        min = n1;
    return min;
}

Methode Aanroepen

Om een methode te gebruiken, moet deze aangeroepen worden. Er zijn twee manieren waarop een methode aangeroepen wordt, namelijk: methode retourneert een waarde of retourneert niets (geen returnwaarde).

Het proces van methode-aanroepen is simpel. Wanneer een programma een methode aanroept, wordt de programmacontrole overgedragen aan de aangeroepen methode. Deze aangeroepen methode geeft dan controle terug aan de aanroeper in twee voorwaarden, wanneer –

• de return-statement wordt uitgevoerd.
• het het eind van de methode bereikt (sluitende accolade).

Methodes die void retourneren, worden beschouwd als aanroep naar een statement. Laten we een voorbeeld overwegen –

System.out.println("Dit is tutorialspoint.com!");

De methode die een waarde retourneert, kan worden begrepen door het volgende voorbeeld –

int resultaat = som(6, 9);

Het volgende voorbeeld demonstreert hoe een methode te definiëren en hoe deze aan te roepen –

public class ExampleMinNumber {
    public static void main(String[] args) {
        int a = 11;
        int b = 6;
        int c = minFunction(a, b);
        System.out.println("Minimum Waarde = " + c);
    }
    /** retourneert het minimum van twee getallen */
    public static int minFunction(int n1, int n2) {
        int min;
        if (n1 > n2)
            min = n2;
        else
            min = n1;
        return min;
    }
}

Dit zal het volgende resultaat produceren –

Minimum waarde = 6

Het void Trefwoord

Het void trefwoord stelt ons in staat om methoden te creëren die geen waarde retourneren. Hier, in het volgende voorbeeld overwegen we een void-methode methodRankPoints. Deze methode is een void-methode, die geen waarde retourneert. Aanroep naar een void-methode moet een statement zijn, namelijk methodRankPoints(255.7);. Het is een Java-statement dat eindigt met een puntkomma zoals getoond in het volgende voorbeeld.

public class ExampleVoid {
    public static void main(String[] args) {
        methodRankPoints(255.7);
    }
    public static void methodRankPoints(double points) {
        if (points >= 202.5) {
            System.out.println("Rank:A1");
        } else if (points >= 122.4) {
            System.out.println("Rank:A2");
        } else {
            System.out.println("Rank:A3");
        }
    }
}

Dit zal het volgende resultaat produceren –

Rank:A1

Parameters Doorgeven per Waarde

Terwijl we werken onder het aanroep-proces, moeten argumenten worden doorgegeven. Deze moeten in dezelfde volgorde zijn als hun respectievelijke parameters in de methode-specificatie. Parameters kunnen per waarde of per referentie worden doorgegeven.

Parameters per waarde doorgeven betekent een methode aanroepen met een parameter. Hierdoor wordt de argumentwaarde doorgegeven aan de parameter.

Voorbeeld

Het volgende programma toont een voorbeeld van parameter per waarde doorgeven. De waarden van de argumenten blijven hetzelfde zelfs na de methode-aanroep.

public class swappingExample {
    public static void main(String[] args) {
        int a = 30;
        int b = 45;
        System.out.println("Voor wisselen, a = " + a + " en b = " + b);
        // Roep de swap-methode aan
        swapFunction(a, b);
        System.out.println("\n**Nu, Voor en Na wisselen waarden zijn hetzelfde hier**:");
        System.out.println("Na wisselen, a = " + a + " en b is " + b);
    }
    public static void swapFunction(int a, int b) {
        System.out.println("Voor wisselen(Binnen), a = " + a + " b = " + b);
        // Wissel n1 met n2
        int c = a;
        a = b;
        b = c;
        System.out.println("Na wisselen(Binnen), a = " + a + " b = " + b);
    }
}

Dit zal het volgende resultaat produceren –

Voor wisselen, a = 30 en b = 45
Voor wisselen(Binnen), a = 30 b = 45
Na wisselen(Binnen), a = 45 b = 30
**Nu, Voor en Na wisselen waarden zijn hetzelfde hier**:
Na wisselen, a = 30 en b is 45

Methode Overloading

Wanneer een klasse twee of meer methoden heeft met dezelfde naam maar verschillende parameters, heet dit methode overloading. Het verschilt van overriding. Bij overriding heeft een methode dezelfde methode-naam, type, aantal parameters, etc.

Laten we het voorbeeld dat eerder besproken werd voor het vinden van minimum getallen van integer-type overwegen. Als, laten we zeggen, we willen het minimum getal van double-type vinden. Dan zal het concept van overloading geïntroduceerd worden om twee of meer methoden met dezelfde naam maar verschillende parameters te creëren.

Het volgende voorbeeld verduidelijkt hetzelfde –

public class ExampleOverloading {
    public static void main(String[] args) {
        int a = 11;
        int b = 6;
        double c = 7.3;
        double d = 9.4;
        int resultaat1 = minFunction(a, b); // zelfde functienaam met verschillende parameters
        double resultaat2 = minFunction(c, d);
        System.out.println("Minimum Waarde = " + resultaat1);
        System.out.println("Minimum Waarde = " + resultaat2);
    }
    // voor integer
    public static int minFunction(int n1, int n2) {
        int min;
        if (n1 > n2)
            min = n2;
        else
            min = n1;
        return min;
    }
    // voor double
    public static double minFunction(double n1, double n2) {
        double min;
        if (n1 > n2)
            min = n2;
        else
            min = n1;
        return min;
    }
}

Dit zal het volgende resultaat produceren –

Minimum Waarde = 6
Minimum Waarde = 7.3

Overloading van methodes maakt het programma leesbaarder. Hier worden twee methodes gegeven met dezelfde naam maar met verschillende parameters. Het minimum getal van integer en double types is het resultaat.

Command-Line Argumenten Gebruiken

Soms wilt u informatie in een programma doorgeven wanneer u het uitvoert. Dit wordt bereikt door command-line argumenten door te geven aan main().

Een command-line argument is de informatie die direct volgt op de programma-naam op de commandoregel wanneer het wordt uitgevoerd. Om toegang te krijgen tot command-line argumenten binnen een Java-programma is vrij eenvoudig. Ze worden opgeslagen als strings in de String-array die aan main() wordt doorgegeven.

Voorbeeld

Het volgende programma toont alle command-line argumenten waarmee het wordt aangeroepen –

public class CommandLine {
    public static void main(String args[]) {
        for(int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]: " + args[i]);
        }
    }
}

Probeer dit programma uit te voeren zoals hier getoond –

$java CommandLine dit is een commandoregel 200 -100

Dit zal het volgende resultaat produceren –

args[0]: dit
args[1]: is
args[2]: een
args[3]: commandoregel
args[4]: 200
args[5]: -100

De this Trefwoord

this is een trefwoord in Java dat wordt gebruikt als referentie naar het object van de huidige klasse, binnen een instance-methode of een constructor. Met this kunt u verwijzen naar de leden van een klasse zoals constructors, variabelen en methoden.

Let op – Het trefwoord this wordt alleen gebruikt binnen instance-methodes of constructors.

In het algemeen wordt het trefwoord this gebruikt om –

• De instance-variabelen te differentiëren van lokale variabelen als ze dezelfde namen hebben, binnen een constructor of methode.

class Student {
    int leeftijd;
    Student(int leeftijd) {
        this.leeftijd = leeftijd;
    }
}

• Eén type constructor (geparametriseerde constructor of default) aanroepen vanuit een andere in een klasse. Dit heet expliciete constructor-roepe.

class Student {
    int leeftijd;
    Student() {
        this(20);
    }
    Student(int leeftijd) {
        this.leeftijd = leeftijd;
    }
}

Voorbeeld

Hier is een voorbeeld dat this trefwoord gebruikt om toegang te krijgen tot de leden van een klasse. Kopieer en plak het volgende programma in een bestand met de naam, This_Example.java.

public class This_Example {
    // Instance variabele num
    int num = 10;
    This_Example() {
        System.out.println("Dit is een voorbeeldprogramma over trefwoord this");
    }
    This_Example(int num) {
        // Roep de default constructor aan
        this();
        // Wijs de lokale variabele num toe aan de instance variabele num
        this.num = num;
    }
    public void greet() {
        System.out.println("Welkom bij Tutorialspoint");
    }
    public void print() {
        // Lokale variabele num
        int num = 20;
        // Print de lokale variabele
        System.out.println("waarde van lokale variabele num is: " + num);
        // Print de instance variabele
        System.out.println("waarde van instance variabele num is: " + this.num);
        // Roep de greet-methode van een klasse aan
        this.greet();
    }
    public static void main(String[] args) {
        // Instantieer de klasse
        This_Example obj1 = new This_Example();
        // Roep de print-methode aan
        obj1.print();
        // Geef een nieuwe waarde door aan de num-variabele via de geparametriseerde constructor
        This_Example obj2 = new This_Example(30);
        // Roep de print-methode opnieuw aan
        obj2.print();
    }
}

Dit zal het volgende resultaat produceren –

Dit is een voorbeeldprogramma over trefwoord this
waarde van lokale variabele num is: 20
waarde van instance variabele num is: 10
Welkom bij Tutorialspoint
Dit is een voorbeeldprogramma over trefwoord this
waarde van lokale variabele num is: 20
waarde van instance variabele num is: 30
Welkom bij Tutorialspoint

Variabele Argumenten (var-args)

JDK 1.5 stelt u in staat om een variabel aantal argumenten van hetzelfde type aan een methode door te geven. De parameter in de methode wordt als volgt gedeclareerd –

typeNaam... parameterNaam

In de methode-declaratie specificeert u het type gevolgd door een ellipsis (...). Slechts één variable-length parameter mag in een methode gespecificeerd worden, en deze parameter moet de laatste parameter zijn. Alle reguliere parameters moeten ervoor gaan.

Voorbeeld

public class VarargsDemo {
    public static void main(String args[]) {
        // Roep methode aan met variable args
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }
    public static void printMax(double... numbers) {
        if (numbers.length == 0) {
            System.out.println("Geen argument doorgegeven");
            return;
        }
        double resultaat = numbers[0];
        for (int i = 1; i < numbers.length; i++)
            if (numbers[i] > resultaat)
                resultaat = numbers[i];
        System.out.println("De max waarde is " + resultaat);
    }
}

Dit zal het volgende resultaat produceren –

De max waarde is 56.5
De max waarde is 3.0

De finalize() Methode

Het is mogelijk om een methode te definiëren die net voor de definitieve vernietiging van een object door de garbage collector wordt aangeroepen. Deze methode heet finalize(), en kan worden gebruikt om ervoor te zorgen dat een object netjes wordt beëindigd.

Bijvoorbeeld, u kunt finalize() gebruiken om ervoor te zorgen dat een open bestand dat door dat object wordt bezit, wordt gesloten.

Om een finalizer aan een klasse toe te voegen, definieert u simpelweg de finalize()-methode. De Java-runtime roept die methode aan wanneer het op het punt staat een object van die klasse te recyclen.

Binnen de finalize()-methode specificeert u die acties die moeten worden uitgevoerd voordat een object wordt vernietigd.

De finalize()-methode heeft deze algemene vorm –

protected void finalize() {
    // finalisatiecode hier
}

Hier is het trefwoord protected een specifier die toegang tot finalize() voorkomt door code gedefinieerd buiten zijn klasse.

Dit betekent dat u niet kunt weten wanneer of zelfs of finalize() zal worden uitgevoerd. Bijvoorbeeld, als uw programma eindigt voordat garbage collection plaatsvindt, zal finalize() niet uitgevoerd worden.