为什么这个java递归方法不创建无限循环？

我是android开发的新手，在阅读一个代码示例时，我遇到了一个从内部调用的方法，所以从逻辑上讲，它应该创建一个调用自身的无限循环。但事实并非如此。为什么?

在my

MainActivity.java中

 public void onWishlistSelected() {
        launchUserSpecificFragment(new WishlistFragment(), WishlistFragment.class.getSimpleName(), new LoginDialogInterface() {
            @Override
            public void successfulLoginOrRegistration(User user) {
                // If login was successful launch WishlistFragment.
                onWishlistSelected(); // Why doesn't this create infine loop?
            }
        });
    }

并称之为：

public boolean onOptionsItemSelected(MenuItem item) {

        int id = item.getItemId();

        if (id == R.id.action_wish_list) {
            onWishlistSelected();
            return true;
        } else if (id == R.id.action_cart) {
            onCartSelected();
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

编辑

以下是
launchUserSpecificFragment

   private void launchUserSpecificFragment(Fragment fragment, String transactionTag, LoginDialogInterface loginListener) {
        if (SettingsMy.getActiveUser() != null) {
            replaceFragment(fragment, transactionTag);
        } else {
            DialogFragment loginDialogFragment = LoginDialogFragment.newInstance(loginListener);
            loginDialogFragment.show(getSupportFragmentManager(), LoginDialogFragment.class.getSimpleName());
        }
    }

 private void replaceFragment(Fragment newFragment, String transactionTag) {
        if (newFragment != null) {
            FragmentManager frgManager = getSupportFragmentManager();
            FragmentTransaction fragmentTransaction = frgManager.beginTransaction();
            fragmentTransaction.setAllowOptimization(false);
            fragmentTransaction.addToBackStack(transactionTag);
            fragmentTransaction.replace(R.id.main_content_frame, newFragment).commit();
            frgManager.executePendingTransactions();
        } else {
            Timber.e(new RuntimeException(), "Replace fragments with null newFragment parameter.");
        }
    }

和
replaceFragment

   private void launchUserSpecificFragment(Fragment fragment, String transactionTag, LoginDialogInterface loginListener) {
        if (SettingsMy.getActiveUser() != null) {
            replaceFragment(fragment, transactionTag);
        } else {
            DialogFragment loginDialogFragment = LoginDialogFragment.newInstance(loginListener);
            loginDialogFragment.show(getSupportFragmentManager(), LoginDialogFragment.class.getSimpleName());
        }
    }

 private void replaceFragment(Fragment newFragment, String transactionTag) {
        if (newFragment != null) {
            FragmentManager frgManager = getSupportFragmentManager();
            FragmentTransaction fragmentTransaction = frgManager.beginTransaction();
            fragmentTransaction.setAllowOptimization(false);
            fragmentTransaction.addToBackStack(transactionTag);
            fragmentTransaction.replace(R.id.main_content_frame, newFragment).commit();
            frgManager.executePendingTransactions();
        } else {
            Timber.e(new RuntimeException(), "Replace fragments with null newFragment parameter.");
        }
    }

onWishlistSelected
是而不是调用自身，因此这里没有无限递归

它正在调用
launchUserSpecificFragment
，它接收实现
LoginDialogInterface
的匿名类的实例作为参数

匿名类包含一个调用
onWishlistSelected
的
successfulloginoregistration
方法，但是调用
onWishlistSelected
并不一定执行该
successfulloginoregistration
方法。当执行
successfulloginoregistration
时，将根据
launchUserSpecificFragment
的逻辑执行
successfulloginoregistration
，此方法永远不会无限调用，原因是有
successfulloginoregistration
接口正在执行您的
onWishlistSelected
方法。简而言之，
onWishlistSelected
方法只有在
接口
在
成功登录
中获得回调时才会执行。请注意，调用
onWishlistSelected
的位置在匿名类中，而不是直接在
onWishlistSelected
方法本身中

如果仔细查看，对
onWishlistSelected
的调用被放入名为
successfulloginoregistration
的方法中。这意味着只有在调用
successfulloginoregistration
时，才会调用
onWishlistSelected

那么什么时候将调用
成功登录
？我无法从你给出的代码数量中知道这一点

现在我们假设调用了
successfulloginoregistration
。因此，将调用
onWishlistSelected
，但只有在下次调用
成功登录时才会调用
onWishlistSelected

现在，您可能会问，“堆栈跟踪不会被这两个方法调用填充？”答案可能不是
onWishlistSelected
可能首先返回，以便代码的其他部分能够调用
SuccessfullLoginRegistration
。因此堆栈跟踪不会溢出

我将使用一个更容易理解的示例来说明这一点：

private static JButton btn = new JButton("press me");
public static void main(String[]args) throws Exception {
    JFrame frame = new JFrame();
    frame.add(btn);
    someMethod();
    frame.setVisible(true);
}

public static void someMethod() {
    btn.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("button pressed");
            someMethod();
        }
    });
}

这不会创建无限循环
someMethod
仅在用户按下按钮时执行。当用户按下按钮时，
actionPerformed
被调用，
someMethod
也被调用。但是什么也不会发生，直到用户再次单击按钮。
onWishListSelected方法不会调用自身。它定义了SuccessfullLoginRegistration方法，但从未调用它。我相信这就是你想要的

public void onWishlistSelected() {
        boolean loginSuccess = false; 
        launchUserSpecificFragment(new WishlistFragment(), WishlistFragment.class.getSimpleName(), new LoginDialogInterface() {
            @Override
            public void successfulLoginOrRegistration(User user) {
                // If login was successful launch WishlistFragment.
            }
            // set true when login successfully .
            // loginSuccess = true;
        });
        // call untill successfully logged in.
        if(loginSuccess == false){
          onWishlistSelected();
        }
}

因此，当在
内部调用它时，为什么不再次调用
launchUserSpecificFragment
？RameshPareek您必须查看
launchUserSpecificFragment
的代码才能看到它在做什么。否则就无法判断它调用什么或不调用什么。@RameshPareek它会的。但是，
successfulloginoregistration
将不会被再次调用，至少不会立即调用。请再详细说明一下--
OnwishSelected
可能会首先返回“这里的first是什么意思？”？我还用更多相关的代码更新了它，您现在可以帮助吗？
onWishlistSelected
将首先返回，然后其他地方的代码将在未知时间调用
successfulloginoregistration
（我们甚至无法从您添加的代码中知道什么时候。您需要找到名为
successfulloginoregistration
）的方法调用。调用
成功后，将再次调用
onWishlistSelected
@拉梅什帕雷克