Question

我正在开发一个Android项目，我正面临这种情况。

我有2个课程：

class A extends B
{

openDoor(){
//impl
}

closeDoor(){
//impl
}

}

class X extends Y{

openDoor(){
//impl
}

closeDoor(){
//impl
}

}

现在，如果您观察到两个类openDoor()和closeDoor()

中常见的两种方法

避免重复方法的最佳方法是什么？

我的方法

class ContainingDuplicateMethods{

     openDoor(){
    //impl
    }

    closeDoor(){
    //impl
    }

    }
   }

在类中创建ContainingDuplicateMethods对象并调用方法，我们将其称为策略模式，但这是最佳解决方案吗？为什么因为在大型项目中我们不能遵循这种方法而且人们说它不是很好的做法，在这种情况下我需要遵循什么方法呢？

请注意class A and X已经扩展了其他类，我也不想使用静态因为 - 当程序执行开始时静态成员被加载到内存中并且将在内存中直到程序终止，比如我的代码连续运行数天或数周，并继续使用静态引用创建许多对象，因此我们可能会耗尽内存。

Answer 1

“赞成合成而非继承”是一件值得记住的事情。

打开和关闭Door课程。添加Door作为A和B的成员。

Voila，完成了工作。

所以A.getDoor().close()。 B.getDoor().open()等。

如果您需要A和B的通用界面（这样您可以在某处使用），那么创建

interface HasDoor {
    Door getDoor();
}

现在A和B可以扩展您喜欢的任何课程并实施HasDoor。任何需要门的类都可以接受HasDoor（或直接接受Door对象）并打开，关闭等。

没有重复的代码，充分的灵活性。

如果您需要Door在[{1}}和A中调用方法，请将B类创建为摘要，并在Door和A中实现{1}}作为匿名内部类。抽象方法将从B调用，然后您可以在调用这些方法时执行Door和A中所需的任何处理。

例如，A类成为：

门在哪里：

 class A implements HasDoor {
      private Door door = new Door() {
          @override void notifyDoorChanged(boolean closed) {
                // The door is telling us its been opened or closed
          }
      }

      @override
      public Door getDoor() {
           return door;
      }
 }

请注意，这与策略模式类似 - 但它并不完全相同。策略模式有一个主对象，然后您插入多个策略（即不同形式的门）。这有一个门和多个其他对象使用相同类型的门，虽然你可以扩展它以使用策略模式，并很容易有多个门实现。

Answer 2

这是Tim B.发布的答案的实施这是一种非常灵活的方法。它遵循面向对象重用的原则：

识别出变化并将其与保持不变的内容区分开来。
编程到接口，而不是实现。

赞成对象组合而不是继承。

public class Main {

    public static void main(String[] args) {
        X x = new X();
        A a = new A();
        x.getDoor().open();
        x.getDoor().close();
        a.getDoor().open();
        a.getDoor().close();
    }
}


interface HasDoor {
    Door getDoor();
}

interface Door {
    public void open();
    public void close();
}

class A extends B implements HasDoor {
Door d;

@Override
public Door getDoor() {
    Door door = new Door() {
        public void open() {
            System.out.println("Open A's Door");
        }

        public void close() {
            System.out.println("Close A's Door");
        }
    };
    return door;
}

}

类X扩展Y实现HasDoor { 门d;

@Override
public Door getDoor() {
    Door door = new Door() {
        public void open() {
            System.out.println("Open X's Door");
        }

        public void close() {
            System.out.println("Close X's Door");
        }
    };
    return door;
}

}

B班{} Y {}

如果您不想使用HasDoor接口，可以在类X和A类中声明构造函数，以初始化Door实例。

示例;

class X extends Y {
    Door d;
     public X() {
         d = new Door() {
            public void open() {
                System.out.println("Open X's Door");
            }

            public void close() {
                System.out.println("Close X's Door");
            }
        };

     }



}

Answer 3

所以这里你的班级a和班级a必须遵循相同的功能。这两个类都有相同的功能。

由于类已经扩展了另一个类，我们可以使用接口

interface door
{
 openDoor(){
    }

    closeDoor(){
    }


}

a类和x类都可以实现门界面。 enter image description here

一个类可以实现任意数量的接口，但只能扩展一个类。

如果类门的实现是相同的，我们可以这样做

class Door
{
openDoor(){
impl//
    }

    closeDoor(){
impl//
    }


}
class A extends b
{
Door d=new Door();
d.opendoor();
d.closeDorr();


}

Answer 4

是的，创建一个包含公共代码的抽象类。让这个抽象类实现一个包含必要方法的接口。

让其他类扩展抽象类。

Answer 5

我认为你应该创建一个方法openDoor（）和closeDoor（）的接口。之后，从该接口继承A类和X类并实现方法。如果方法实现类似，那么您可以使用静态方法创建实用程序类。

Answer 6

public interface YourInterface{
  public void openDoor();
  public void closeDoor();
}

public abstract class YourAbstractClass implements YourInterface{
  public abstract void openDoor();
  public abstract void closeDoor();
}

public class YourClass extends YourAbstractClass{
  @Override
  public void openDoor();
  public void closeDoor();
}

public class YourSubClass extends YourClass{
  //you can just call super methods here
  super.openDoor();
  super.closeDoor();
}

如果两个类扩展不同的类，避免重复代码的最佳方法

6 个答案: