Beispielanalyse für die Verwendung von Java-Methoden

1. Das Konzept und die Verwendung von Methoden

1.1. Was ist eine Methode

Sie ähnelt einer „Funktion“. C-Sprache. Die Funktionen sind wie folgt:

1 Der Code kann modular organisiert werden (wenn die Codegröße komplexer ist). Eine Kopie des Codes kann an mehreren Stellen verwendet werden.

3 Machen Sie den Code verständlicher und einfacher.

4 Rad.#🎜🎜 #

1.2. Definition der Methode

Definitionsformat:

Beispiel: Schreiben Sie a Funktion, um herauszufinden, wie viele Elemente die Summe der Fakultäten ist public static, sodass nur die darin aufgerufenen Methoden eine statische Methode sein können.

2. Rückgabewerttyp: Wenn die Methode einen Rückgabewert hat, muss der Rückgabewerttyp mit dem zurückgegebenen Entitätstyp übereinstimmen. Wenn kein Rückgabewert vorhanden ist, muss er als void geschrieben werden.

3. Methodenname: Verwenden Sie einen kleinen Kamelkasten, um ihn zu benennen.

4. Parameterliste: Wenn die Methode keine Parameter hat, schreiben Sie nichts in (). Wenn Parameter vorhanden sind, müssen Sie den Parametertyp angeben, um mehrere Parameter zu trennen.

5. Methodenkörper: Die Anweisung, die innerhalb der Methode ausgeführt werden soll.

6. In Java müssen Methoden in Klassen geschrieben werden.

7. In Java können Methoden nicht verschachtelt werden.

8. In Java gibt es keine Methodendeklaration. (Deklaration und Definition werden nicht unterschieden). >Suchen Sie die Methodenadresse—>Der Methodenkörper, der die aufgerufene Methode ausführt—>Die aufgerufene Methode endet und kehrt zurück—>Kehren Sie zur aufrufenden Hauptmethode zurück und setzen Sie die Ausführung fort

Bildsymbol: # 🎜🎜#

Hinweis:

1: Beim Definieren einer Methode wird der Code der Methode nur dann ausgeführt, wenn dies der Fall ist aufgerufen Wird ausgeführt.

2, eine Methode kann mehrmals aufgerufen werden.

1.4 Die Beziehung zwischen tatsächlichen Parametern und formalen Parametern (wichtig)

#🎜 🎜#Denn die Beziehung zwischen formalen Parametern und tatsächlichen Parametern ist sicherlich jedem bekannt, das heißt, die formalen Parameter sind eine temporäre Kopie der tatsächlichen Parameter, was bedeutet, dass Änderungen der formalen Parameter keine Auswirkungen auf die tatsächlichen Parameter haben.

Veranschaulichung des spezifischen Grundes: (Da die spezifischen Probleme im Zusammenhang mit Funktionsstapelrahmen komplizierter sind, finden Sie hier eine kurze Erklärung)

#🎜 🎜 #

Wie Sie auf dem Bild sehen können, werden beim Aufruf nach Wert die Werte der formalen und tatsächlichen Parameter überhaupt nicht im selben Raum gespeichert, sodass sie sich nicht gegenseitig stören. Wenn Sie in der C-Sprache die formalen Parameter ändern möchten, müssen Sie sie über die Adresse aufrufen. In Java gibt es jedoch keine Übergabeadresse. Die Lösung kann nur darin bestehen, Referenzen zu verwenden (. was später im Detail vorgestellt wird).

2. Methodenüberladung

2.1. Warum eine Methodenüberladung erforderlich ist

public class TeseDemo220424 {
//    计算某一个数的阶乘
    public static int func(int n){
        int ret = 1;
        for(int i = 1;i <= n;i++){
            ret *= i;
        }
        return ret;
    }
//    计算前多少项阶乘之和
    public static int func1(int k){
        int sum = 0;
        for(int i = 1;i <= k;i++){
            sum += func(i);
        }
        return sum;
    }
    public static void main(String[] args) {
//        写函数来求阶乘之和
        Scanner myscanner = new Scanner(System.in);
        System.out.println("请输入你想要求取前多少项的阶乘的和:");
        int num = myscanner.nextInt();
        int sum = func1(num);
        System.out.println("前 " + num + "项的阶乘和为" + sum);
    }
}

Sehen Sie sich diesen Code an, die beiden Methoden addint und adddouble , der Zweck besteht darin, die Summe zweier Zahlen zu ermitteln. Sie müssen jedoch zwei verschiedene Funktionen mit unterschiedlichen Funktionsnamen definieren. Manchmal bereitet die Benennung jedoch Kopfschmerzen. Da die wesentlichen Funktionen der Methoden gleich sind, die Parameter jedoch unterschiedlich sein können, ist dies auch möglich verwenden wir alle den gleichen Funktionsnamen?

Die Antwort lautet „Ja“, und das nennt man Methodenüberladung.

2.2. Definition der Methodenüberladung

Wenn in Java mehrere Methoden denselben Namen und unterschiedliche Parameterlisten haben, werden sie als überladen bezeichnet. Das heißt, derselbe Name, aber mit unterschiedlicher Bedeutung.

public class TestDemo220426 {
    public static int addInt(int x,int y){
        return x + y;
    }
    public static double addDouble(double x,double y){
        return x + y;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int ret = addInt(a,b);

        double c = 11.1;
        double d = 12.1;
        double ret1 = addDouble(c,d);
    }
}

Screenshot des laufenden Programms:

Wie aus dem obigen Programm ersichtlich ist, implementieren sie alle die Funktion von Zusätzlich, aber Was definiert ist, sind zwei verschiedene Funktionsimplementierungen, aber die Funktionsnamen sind gleich. Dies ist eine Funktionsüberladung. Der Compiler ruft die entsprechende Funktion basierend auf den von Ihnen übergebenen Parametern auf.

Hinweis:

1 Die Methodennamen müssen gleich sein.

2. Die Parameterliste muss unterschiedlich sein (die Anzahl der Parameter ist unterschiedlich, die Art der Parameter ist unterschiedlich, die Reihenfolge der Typen muss unterschiedlich sein) (müssen durch Parameter unterschieden werden) #🎜🎜 #

3. Es spielt keine Rolle, ob die Rückgabewerttypen gleich sind

4 Sie können keine zwei Funktionen definieren, die sich nur durch ihre Rückgabewerte unterscheiden.# 🎜🎜#

5. Wenn der Compiler den Code kompiliert, werden die tatsächlichen Parametertypen abgeleitet und die Methode basierend auf den Ableitungsergebnissen aufgerufen 🎜#

Die Methodensignatur lautet: Die endgültige Methode nach dem Kompilieren und Ändern durch den Compilernamen. Die spezifische Methode ist: der vollständige Pfadname der Methode + Parameterliste + Rückgabewerttyp, der den vollständigen Namen der Methode darstellt. Wird zur Unterscheidung überladener Funktionen verwendet.

So zeigen Sie unsere Methodensignatur an:

1 Kompilieren Sie zunächst das Projekt, um eine .class-Bytecode-Datei zu generieren

2 . Geben Sie in der Konsole das Verzeichnis ein, in dem sich die .class befindet, die Sie anzeigen möchten.

3

3.1. Das Konzept der Rekursion

Definition: Eine Methode, die sich während der Ausführung selbst aufruft, wird als „rekursiv“ bezeichnet. Notwendige Bedingungen:

# 🎜🎜#1. Rekursive Formel

2.

3.2、递归过程分析

    public static  int func(int num){
        if(num == 1){
            return 1;
        }
        return num*func(num - 1);
    }
    public static void main(String[] args) {
//        递归求阶乘
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num = scan.nextInt();
        int ret = func(num);
        System.out.println("阶乘为：" + ret);
    }
}

在这里我们以求一个数的阶乘的代码为例来分析一个递归的过程：

递归的过程其实不复杂，看成两个部分，一个是递出去，而是归回来，上面的蓝色箭头是递的过程，红色箭头是归的过程。

3.3、递归小练习

• 按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)

public class TestDemo220427 {
    public static void myprint(int num){
        if(num < 10){
            System.out.println(num%10);
            return;
        }
        myprint(num/10);
        System.out.println(num%10);
        return;
    }
    public static void main(String[] args) {
//        递归实现按顺序打印数字的每一位
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num = scan.nextInt();
        myprint(num);
    }
}

• 求斐波那契数列的第 N 项

public class TestDemo220428 {
    public static int fib1(int n){
        int f1 = 1;
        int f2 = 1;
        int f3 = 1;
        for(int i = 3;i <= n;i++){
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;
    }
    public static int fib(int n){
        if(n == 1 || n == 2){
            return 1;
        }
        return fib(n-1) + fib(n-2);
    }
    public static void main(String[] args) {
//        递归求斐波那契数列的第n项
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入您想要求取的项数：");
        int n = scan.nextInt();
        int ret = fib1(n);
        System.out.println("第" + n + "项为：" + ret);
    }
}

利用递归求斐波那契数列的第n项的话，其实是一个双路递归，不推荐这种求解的方法，因为会算很多重复的项，效率很低，一般都是选择循环迭代的方式来生成斐波那契数即可。

Das obige ist der detaillierte Inhalt vonBeispielanalyse für die Verwendung von Java-Methoden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!