java - 如何有效地将一个方法划分为子方法？

Question

所以基本上这个线程归结为我想要一些私有(private)方法来表示另一个方法中的代码块。我知道 Java 中作用域的工作原理，但有时我希望事情能以不同的方式工作:

假设我的类中有一个方法doLotsOfStuff()，它可以做不止一件事。自然地，人们会将事物分为几种 VOID 类型的方法 doThis() 和 doThat()。您遇到此类问题:

1) 如果没有首先，我无法再在 doThis() 和 doThat() 中对 doLotsOfStuff() 中定义的任何数据进行操作传递所有必要的参数，这不会使它们无效!例如doThis(int doLotsOfStuffsInt)这意味着如果我想要一系列调用，则必须在一行参数中传递相同的变量。 ..这导致了这个:

2) doThis() 和 doThat() 设置为 private 对于同一类中的所有其他方法仍然可见，即使我只想使用它们对于doLotsOfStuff()。拥有一长串只打算使用一次的子方法现在会使整个类变得困惑。

这是我希望存在的:a、b、c、d 是同一类中的私有(private)方法。 -> 表示对方法的调用。

a() -> b() -> c()

c() 可以自由使用 a() 或 b() 中的变量，而无需在链上传递参数。

d() -/-> c()

c() 不能被 d() 调用，因为 c() 对于 a() 及其任何后续调用者来说只是“本地”的。

考虑这个简短的例子:

private void someMethod()
{
    char a = 'a';
    printA();
}


private void printA() {
    System.out.println(a);  //a cannot resolve, but I don't want to pass it as an argument from someMethod()!
}

有没有一种方法可以实现这一点，而不必传递 a 作为参数？某种声明的行“private void printA() 取决于 someMethod”？

这不是一个很好的功能吗？如果没有，为什么？你会怎么做？

Answer 1

您要查找的内容名为 Closure范围:

闭包在Java中并不是原生支持的，老实说模仿起来也不是很优雅。这种能力是大多数动态语言(例如 Groovy 或 JavaScript

)中固有的

一个Closure捕获其定义范围内的变量。

If you use final references您可以在内部类中引用它们，并使用内部类在闭包中模仿数据隐藏的行为。

Q32766010.java

public class Q32766010
{
    public static void main(final String[] args)
    {
        final Example e = new Example();
        e.doSomething(23,42);
    }

    public static class Example
    {
        public void doSomething(final int a, final int b)
        {
            class ClosureLikeThing {
                ClosureLikeThing doThis() { System.out.println("a = " + a); return this; }
                ClosureLikeThing doThat() { System.out.println("b = " + b); return this; }
            }
            new ClosureLikeThing().doThis().doThat();
        }
    }
}

输出

a = 23
b = 42

这会隐藏公共(public)界面的内部细节。

这将隐藏您正在寻找的数据/方法。它是一个方法对象模式的实现可能会困扰新程序员，因为它在 Java 中并不经常使用。这种内部类的用法在 Python、JavaScript 和 Ruby 等更动态的语言中很普遍。

这可以帮助您在支持代码折叠的优秀 IDE 中整理代码。如果您将 IDE 设置为折叠所有内部类，则会减少源代码吵闹。

更多行代码并不总是坏事，如果您使用像 Intellij IDEA 这样的工具更容易自动重构某些内容，那么更多行代码会更好，因为它可以自动维护。

多写几行代码来缩小范围几乎总是更好。范围越窄，可能的副作用就越少，并且更容易维护和调试，因为由于范围窄，该代码的影响以及该代码的影响都是最小的并且明显明显。

这个习惯用法在 Java 中主要用于诸如迭代器和 FluentBuilder 模式实现之类的事情，以隐藏实现的细节。这是一个例子'UrlBuilder' .

如果您有多个实现，则可以选择使用接口(interface):

这以相同的方式工作，但如果您需要同一接口(interface)的不同行为，则允许您创建多个实现。

public static class Example
{
    interface ClosureLikeThing
    {
        public ClosureLikeThing doThis();

        public ClosureLikeThing doThat();
    }

    public void doSomething(final int a, final int b)
    {
        new ClosureLikeThing()
        {
            @Override
            public ClosureLikeThing doThis()
            {
                System.out.println("a = " + a);
                return this;
            }

            @Override
            public ClosureLikeThing doThat()
            {
                System.out.println("b = " + b);
                return this;
            }
        }.doThis().doThat();
    }
}