Question

interface Y {
 void search(String name);
}
class A implements Y {
  void search(String name) {
     //Is it possible to say: "If I was called from class B then do a search("B");
  }
}

class B extends A {
}

public class Main {
    public static void main(String[] args) {
      B b = new B();
      b.search();
    }
}

鉴于以上代码，可以在超类中推断哪个子类用于调用方法？

我想这样做的原因是因为Search中的代码对于所有子类非常相似，唯一改变的是Classname，所以我认为不需要在每个子类中覆盖。我已更新代码以反映这一点。如果有更好的方法，请告诉我/

Answer 1

在this.getClass()方法中调用search将为您提供当前实例的具体类。

例如：

class Example
{
    static class A {
        public void search() {
            System.out.println(getClass());
        }
    }

    static class B extends A {}

    public static void main (String[] args) throws java.lang.Exception
    {
        new A().search();
        new B().search();
    }
}

输出

class Example$A
class Example$B

Answer 2

最干净的方法是覆盖每个子类中的方法。

interface Y {
    void search();
}

class A implements Y {
    public void search(){
        search("A");
    }

    protected void search(String name) {
        // implement your searching algoithm here
    }
}


class B extends A {
    public void search(){
        search("B");
    }
}

public class Main {
    public static void main(String[] args) {
        B b = new B();
        b.search();
    }
}

这就是继承被认为有效的方式。超类不应该知道它的子类。而且，如果您扩展课程B，您可以轻松地：

- 保持与B相同的行为：

class C extends B {
    // do nothing, when calling search, it calls the method implemented in B
}

- 更改行为以搜索"C"

class C extends B {
    public void search(){
        search("C"); // or search("whateveryouwant")
    }
}

Answer 3

您可以简单地覆盖B类中的方法。另一种方法是将search()方法写为

 void search() {
    if (this.getClass().equals(B.class)) {
        //The logic for B
    } else if (this.getClass().equals(A.class)) {
        //The logic for A
    }
}

您必须提供该类的完全限定名称。

Answer 4

更好地遵循模板模式。

interface Y {
 void search(String name);
}

abstract class AbstractionTemplate implements Y{

    @Override
    public void search(String name) {
      //a lot of code.
        System.out.println("common stuff start");
        doImplspecificStuffOnly();
        System.out.println("common stuff end");
      //a lot of code.

    }

    abstract void doImplspecificStuffOnly();

}

class A extends  AbstractionTemplate{

  @Override
  void doImplspecificStuffOnly() {
     System.out.println("a's stuff");
  }
}

class B extends A {
     @Override
      void doImplspecificStuffOnly() {
         System.out.println("B's stuff");
      }

}

public class Main {
    public static void main(String[] args) {
      B b = new B();
      b.search("hey");
    }
}

在Java中，是否可以在运行时检查调用方法的子类？

4 个答案: