如何在实现接口的类中重写方法

Question

我有一个Readable接口，并且有一个实现它的类ReadableImpl 。

public interface Readable {
    void doThis();
    void doThat();
} 

public class ReadableImpl implements Readable {
    public void doThis() {
        System.out.println("do this");
    }

    public void doThat() {
        System.out.println("do that");
    }
}

如果我想重写方法doThis()怎么办？ 我应该在另一个类中实现Readable吗？

编辑：我不想编辑类ReadableImpl

Answer 1

从技术上讲，您正在ReadableImpl中实现（有些人称其为Override）。 如果要再次重写，则它必须在扩展ReadableImpl的类内，而不必再次实现Readable 。 只是，

public class ReadableImpl2 extends ReadableImpl {
    @override
    public void doThis() {
        System.out.println("do this overriden");
    }

}  

Answer 2

您的示例已经覆盖了它！ 您可以直接在类ReadableImpl重写doThis() 。

只要在类中实现接口，就可以通过在该类中编写完全相同的方法名称/返回类型/参数来覆盖接口中的任何方法。

Answer 3

这取决于您需要做什么以及与ReadableImpl的兼容性级别。

您可以继承ReadableImpl并重写doThis ：

public class ReadableImpl2 extends ReadableImpl {
    @override
    public void doThis() {
        System.out.println("do this 2");
    }
}

如果您无权访问实例化，则可以使用代理：

public class ReadableProxy implements Readable {
    private final Readable delegate;

    public ReadableProxy(Readable delegate) {
        this.delegate = delegate;
    }

    public void doThis() {
        System.out.println("do this proxy");
    }

    public void doThat() {
        delegate.doThat();
    }
}

Answer 4

你的问题

如果我想重写方法doThis（）怎么办？ 我应该在另一个类中实现Readable吗？

我认为这还不是很清楚，因为与扩展/实现相关的操作命名有些混杂。 因此，让我尝试回答您的问题，以使用您的示例为例，说明一切

public interface Readable {
    void doThis();
    void doThat();
} 

具有这样的接口，您可以通过使用implements关键字在您选择的类中implement其方法

public class ReadableImpl implements Readable {
    public void doThis() {
        System.out.println("do this");
    }

    public void doThat() {
        System.out.println("do that");
    }
}

现在，如果您想override此方法，唯一的方法是创建extends ReadableImpl新类，因为to override意味着更改 子类中 父类方法的功能 ：

public class ReadableImplChild extends ReadableImpl{

        @Override
        public void doThis() {
            System.out.println("do this more specific way");
        }

        @Override
        public void doThat() {
            System.out.println("do that more specific way");
        }
    }

但是，如果您想要一种完全不同的处理方式（ ReadableImpl正在处理Readable接口方法），则应创建一个新类 ， 该类将implement 引入新功能的该接口。

 public class ReadableTotallyDifferentImpl implements Readable {
        public void doThis() {
            System.out.println("do this totally another way");
        }

        public void doThat() {
            System.out.println("do that totally another way");
        }
    }

您可以（我知道您不想要，但可以） overload方法。 这意味着创建相同功能的新版本，该版本仅在方法参数的数量和/或类型上有所不同

public class ReadableImpl implements Readable {
    public void doThis() {
        System.out.println("do this");
    }

    public void doThat() {
        System.out.println("do that");
    }

    /**
     * this is funciton overloading
     */
    public void doThat(String userSpecific) {
        System.out.println("do that for:" + userSpecific);
    }
}

根据您的问题：

如果我想重写方法doThis（）怎么办？

这要看情况：

1. 如果您想要稍微不同的功能 （我想说，是做事的更具体的方式）->您应该创建一个子类 ，并覆盖其方法
2. 如果要完全不同地实现此接口 ，则应使用新类并以不同的方式实现它
3. 如果您确实必须使用 ReadableImpl类，但是您希望此方法以其他方式工作 ，则可以重载它或更改其实现。