Question

我对OOPS概念不熟悉，在使用抽象类时我有疑问，请明白我的疑问。

我有四个课程：A班，B班，C班和主班。

A，B和C类包含相同的方法名称，但方法定义不同

实施就像，

    class A                          
    {
       getValue();
       setValue();
    }

    class B                          
    {
       getValue();
       setValue();
}

    class C                          
    {
       getValue();
       setValue();
    }

在Main类中，我需要调用setValue（）或getValue（），它可以是上面三个类中的任何一个，如何实现这个场景？

    class Main
    {
      Main()
    {}
        x.setValue();
        x.getValue();
    }

其中x可以是A类或B类或C类的Object。

Answer 1

抽象类定义了可用的方法。在你的情况下，这将是

abstract class YourAbstractClass {
     abstract public int getValue();
     abstract public void setValue(int i);
}

现在你的A，B和C类可以继承这个类。

class A extends YourAbstractClass {
     public int getValue() { return 23; }
     public void setValue(int i) { /* set i */ }
}
class B extends YourAbstractClass {
     public int getValue() { return -3; }
     public void setValue(int i) { /* set i */ }
}
class C extends YourAbstractClass {
     public int getValue() { return 3; }
     public void setValue(int i) { /* set i */ }
}

在您的主要课程中，您可以像这样使用它：

public class Execution {
    public static void main(String[] args) {
        YourAbstractClass o = new A();
        o.getValue();
        o.setValue(3);
    }
}

Answer 2

在您的特定情况下，您不需要抽象类，但需要接口：

public interface I {
   Object getValue();
   Object setValue();
}

然后你的3个A，B和C类必须实现这个接口：

class A implements I {
   Object getValue() {...}
   void setValue( someParam) {...}
}

    class B implements I {
   Object getValue() {...}
   void setValue( someParam) {...}
}

class C implements I {
   Object getValue() {...}
   void setValue( someParam) {...}
}

最后在你的主要课程中：

class Main
{
  Main()
{
    I x = callWhateverYouWantReturningABOrC();
    x.setValue();
    x.getValue();
}

Answer 3

您可以通过以下几种方式实现这一点：

public interface Valuable {
    void getValue();
    void setValue();
}

class A  implements Valuable {
   getValue() { ... }
   setValue() { ... }
}

class B  implements Valuable {
   getValue() { ... }
   setValue() { ... }
}

class C  implements Valuable {
   getValue() { ... }
   setValue() { ... }
}

或......

abstract class Valuable {
    void getValue() { ... }
    void setValue() { ... }
}

class A extends Valuable {
}

class B extends Valuable {
}

class C extends Valuable {
}

或者......你们都是接口和抽象类的混合体。

哪个更合适取决于许多方面，包括方法实现是否相同。如果是，则abstract类会删除一些重复的代码。

Answer 4

如果我的问题正确，您需要创建一个界面：

interface I {
  int getValue();
  void setValue(int x);
}

您的课程将实施它：

class A implements I {..};
class B implements I {..};
class C implements I {..};

然后在您的Main类中，您可以拥有方法，该方法不必知道x变量的具体实现方式（A，B或{ {1}}）它可以调用它的方法：

Answer 5

您可以将Main设为界面。 interface是一个纯粹的抽象类。

public interface Main {
   void setValue();
   void getValue();
}

然后制作A，B和C类来实现主界面

public class A implements Main {
   @Override
   public void setValue() {
      ...
   }

   @Override
   public void getValue() {
      ...
   }
}

public class B implements Main {
   @Override
   public void setValue() {
      ...
   }

   @Override
   public void getValue() {
      ...
   }
}


public class C implements Main {
   @Override
   public void setValue() {
      ...
   }

   @Override
   public void getValue() {
      ...
   }
}

在java中使用抽象类的场景是什么？

5 个答案: