Java 用组合重写方法

考虑以下情况。我想实现

class A

的

methoddA（）

的不同行为，这取决于它从

class D

或

class C

的调用位置。如何实现这一点，方法重写在这里不起作用

class A
{
    public methodA(){ //some code }
}

class B
{
    A a = new A()
    public methodB()
    {
        a.methodA(); 
    }
}

class C
{
    B b = new B();

    public methodC()
    {
        b.methodB();
    }
}

class D
{
    B b = new B();

    public methodD()
    {
        b.methodB();
    }
}

---

这里需要的是多态性。首先创建一个接口-

public interface MyInterface
{
    void methodA();
}

然后为两种不同的行为创建两种不同的实现-

public class First implements MyInterface
{
    public void methodA() {
        // first behavior
    }
}

public class Second implements MyInterface
{
    public void methodA() {
        // second behavior
    }
}

现在创建其他类，如下所示-

class B
{
    public void methodB(MyInterface m)
    {
        m.methodA(); 
    }
}

class C
{
    B b = new B();

    public void methodC()
    {
        // Pass the corresponding behavior implementation
        // as argument here.
        b.methodB(new First());
    }
}

class D
{
    B b = new B();

    public void methodD()
    {
        // Pass the second behavior implementation.
        b.methodB(new Second());
    }
}

---

这将产生更易于维护的代码。

您可以将类名作为字符串传递给方法，并在方法检查中进行传递

if(className.equals("A") // or use isInstanceOf() if you are passing objects of A/B
//do something

if(className.equals("B")
// do something else.

为什么需要两种不同的实现？

---

这个简单的把戏对你有用。。。如果我错了，请纠正我。

我在下面的代码中修改了类A1和类B1的方法签名以接受对象，同样地，在调用类C和类D中的方法时，我们调用了类B1的方法，将其作为引用传递。在类A1中，我们可以检查对象的instanceof并识别调用类

class A1
{
    public void methodA(Object c){ //some code }
        if (D.class.isInstance(c)){
            System.out.println("Called from Class D");
        }else if (C.class.isInstance(c)){
            System.out.println("Called from Class c");
        }else{
            System.out.println("Called from Some diff class");
        }
    }

}

class B1
{
    A1 a = new A1();
    public void methodB(Object c)
    {
        a.methodA(c); 
    }
}

class C
{
    B1 b = new B1();

    public void methodC()
    {
        b.methodB(this);
    }
}

class D
{
    B1 b = new B1();

    public void methodD()
    {
        b.methodB(this);
    }
}


public class Testnew{
    public static void main(String args[]){
        D d = new D();
        d.methodD();

        C c = new C();
        c.methodC();

        B1 b = new B1();
        b.methodB(b);
    }
}

---

您希望实现什么样的不同行为？如果从类C调用，可能会有一些不同的代码，如果从类D调用，可能会有一些不同的代码。为什么要这样做？如果您希望不同的行为取决于调用函数的位置，也许您可以调用不同的方法？听起来像是动态分派，也许a在这种情况下会有所帮助，也许？以这种方式使用

instanceof

几乎总是一种代码味道。有更好的设计方案。