Java 在几个方法中调用一个方法

我有一个类似这样的类：

class A {
    public void method1(){
        iniCall();

        // Do something
        finalCall();
    }

    public void method2(){
        iniCall();

        // Do something different
        finalCall();
    } // ... more methods like this
}

public void call(method){
    iniCall();
    method();
    finalCall();
}

public interface Method {
    public void run();
}

public void call(Method method) {
    iniCall();
    method.run();
    finalCall();
}

call(new Method() {
    public void run() {
        // do your stuff here
    }
});

如何简化调用和最终调用中的

过程，从而避免在每个函数（或多个函数）中编写它们

是否可以执行类似于
调用（method1）
的操作，调用如下内容：

class A {
    public void method1(){
        iniCall();

        // Do something
        finalCall();
    }

    public void method2(){
        iniCall();

        // Do something different
        finalCall();
    } // ... more methods like this
}

public void call(method){
    iniCall();
    method();
    finalCall();
}

public interface Method {
    public void run();
}

public void call(Method method) {
    iniCall();
    method.run();
    finalCall();
}

call(new Method() {
    public void run() {
        // do your stuff here
    }
});

否则，什么是好的选择？
编辑
我看到我的回答提出了一些问题

可运行接口应该由其实例将由线程执行的任何类实现

因此，创建此接口的实例可能会导致不确定性和问题。正如评论中所建议的，您可能希望编写自己的接口并使用它。可能是这样的：

class A {
    public void method1(){
        iniCall();

        // Do something
        finalCall();
    }

    public void method2(){
        iniCall();

        // Do something different
        finalCall();
    } // ... more methods like this
}

public void call(method){
    iniCall();
    method();
    finalCall();
}

public interface Method {
    public void run();
}

public void call(Method method) {
    iniCall();
    method.run();
    finalCall();
}

call(new Method() {
    public void run() {
        // do your stuff here
    }
});

您的
调用
方法将更改为以下内容：

class A {
    public void method1(){
        iniCall();

        // Do something
        finalCall();
    }

    public void method2(){
        iniCall();

        // Do something different
        finalCall();
    } // ... more methods like this
}

public void call(method){
    iniCall();
    method();
    finalCall();
}

public interface Method {
    public void run();
}

public void call(Method method) {
    iniCall();
    method.run();
    finalCall();
}

call(new Method() {
    public void run() {
        // do your stuff here
    }
});

您对该方法的调用如下：

class A {
    public void method1(){
        iniCall();

        // Do something
        finalCall();
    }

    public void method2(){
        iniCall();

        // Do something different
        finalCall();
    } // ... more methods like this
}

public void call(method){
    iniCall();
    method();
    finalCall();
}

public interface Method {
    public void run();
}

public void call(Method method) {
    iniCall();
    method.run();
    finalCall();
}

call(new Method() {
    public void run() {
        // do your stuff here
    }
});

我建议您使用类似的设计或考虑使用模板模式，这可能需要一些重构。
 < P>可以使用lambda表达式（或者如果不使用java 8，实现<代码> Runnaby< /Cube >的匿名类实例）：

在Java中，不能将方法作为参数传递。您可以通过以下方式传递
Runnable
：

public void method1() {
    call(new Runnable() {
        @Override
        public void run() {
            //do something
        }
    });
}

public void method2() {
    call(new Runnable() {
        @Override
        public void run() {
            //do something different
        }
    });
}

public void call(Runnable runnable){
    iniCall();
    runnable.run();
    finalCall();
}

然而，我真的不喜欢这种方法。我认为您可以应用模板设计模式。
与其他建议类似（他们比我快得多-但我总是想提供一个运行示例…），我建议将
Runnable
实例传递给一个方法，该方法一般调用
iniCall（）
，执行
Runnable
，然后调用
finalCall（）

实际工作可以作为专用的
Runnable
实例、lambda或方法引用传入，后者如下所示：

public class RepeatedMethodContents
{
    public static void main(String[] args)
    {
        RepeatedMethodContents r = new RepeatedMethodContents();
        r.callWrapped(r::doSomething);
        r.callWrapped(r::doSomethingDifferent);
    }

    private void callWrapped(Runnable runnable)
    {
        iniCall();
        runnable.run();
        finalCall();
    }

    private void doSomething()
    {
        System.out.println("doSomething");
    }

    private void doSomethingDifferent()
    {
        System.out.println("doSomethingDifferent");
    }

    private void iniCall()
    {
        System.out.println("ini");
    }

    private void finalCall()
    {
        System.out.println("final");
    }

}

根据需要，输出为：

ini
doSomething
final
ini
doSomethingDifferent
final

顺便说一句：对于这样的事情，我会犹豫是否使用反射。通常，有一种更简单、更直接、更不容易出错的方法。
我不确定自己是否喜欢在其他人使用过的上下文中使用
Runnable
。通常，我认为
Runnable
是将在线程、执行器服务等中运行的东西，对此进行备份的方法是：

可运行接口应该由其实例将由线程执行的任何类实现

但是，从头开始做同样的事情是非常简单和快速的。我们可以创建一个抽象类来保存您需要的结构：

public abstract class AbstractClass
{
    private void iniCall() { ... } // Could also be abstract

    private void finalCall() { ... } // Could also be abstract

    public void doTheThing()
    {
        iniCall();
        foo();
        finalCall();
    }

    public abstract void foo();
}

当然，你需要想出更好的名字，但这是起点。然后我们有两个选项：实例化通过扩展这个类而构建的匿名类，或者创建一个新的具体类。下面是使用匿名类的示例：

AbstractClass a = new AbstractClass()
    {
        @Override
        public void foo()
        {
            // Place an implementation here.
            method(); // one example, based on the OP.
        }
    };
a.doTheThing();

下面是你实际上课的方式：

public class ConcreteClass extends AbstractClass
{
    @Override
    public void foo()
    {
        // Place an implementation here.
    }
}
ConcreteClass c = new ConcreteClass();
c.doTheThing();

我主要想提出这个问题，以便您可以了解“匿名类”范例，这类似于能够将函数作为参数传递。其他语言有指向函数、委托等的指针——这就是Java所拥有的。编译器将确保您的匿名类和具体类将实现
foo
，否则它将无法编译，因此您不能只执行“oops”而忘记实现
 例如，您可以使用反射和匹配方法的名称，如
String
，这会有帮助吗？这不是一种模板模式吗？关于编辑后的添加：JavaDocs中的建议并不意味着每个runnable都应该在自己的线程中执行！事实上，这里当然不应该这样做，因为，例如，
finalCall
可能会在
//do something
完成之前调用。我不会投反对票，但我很抱歉-“”。像这样使用它对任何将来看它的人来说都是一个错误。声明自己的类并调用其方法。Runnable并不是为这个设计的。事实上，我同意所有的反对者的意见，我通过提供一个alternative@RudiKershawOrlangure Runnable最初可能设计用于线程，但这不再是它唯一的预期用途；看到了，我强烈建议您回到。其他一切都令人困惑。线程的事情是完全不相关的，可能会让未来的读者感到困惑（当他们确实在那里创建线程时，会造成垃圾），并且没有必要使用自己的
run
方法的接口，因为
Runnable
现在在更广泛的范围内使用（Alex链接到的Brian Goetz的评论证实了这一点）.旁注：由于被调用的方法显然没有参数，因此可以使用引用：
myInstance:：myMethod
如果不是在
{
@njzk2对不起，你是什么意思？代码中根本没有
return
。？！EDIT:你不是指格式，是吗？！