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

android java code-duplication

2022-09-04 01:33:53

我正在开发一个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
    }

    }
   }

在类中创建一个包含重复方法的对象并调用方法，我们称之为策略模式，但这是最佳解决方案吗？为什么因为在大型项目中我们不能遵循这种方法，人们说这不是好的做法，在这种情况下，我需要遵循什么方法？

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

答案 1

“偏爱作文胜过继承”是一件值得记住的有用事情。

有一个开放和关闭的课程。将和作为的成员包括在内。DoorDoorAB

瞧，工作完成了。

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

如果您需要两者的通用接口和（因此您可以在某个地方使用任何一个），然后创建AB

interface HasDoor {
    Door getDoor();
}

现在，可以扩展您喜欢的任何类并实现.任何需要门的类都可以接受（或直接接受对象）并调用open，close等。ABHasDoorHasDoorDoor

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

如果需要重新调用方法，然后将类创建为抽象类，并将其作为匿名内部类实现。抽象方法将从中调用，然后您可以执行在调用这些方法时所需的任何处理。DoorABDoorABDoorAB

例如，类 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;
      }
 }

门在哪里：

 public abstract class Door {
      boolean closed;
      abstract notifyDoorChanged();

      public void close() {
         closed = true;
         notifyDoorChanged(closed);
      }

      // etc
 }

请注意，这与策略模式类似 - 但它并不完全相同。策略模式有一个主对象，然后插入多个策略（即不同形式的门）。这有一个 Door 和多个使用相同类型 Door 的其他对象，尽管您可以扩展它以使用 Strategy 模式，并且非常轻松地实现多个门。

答案 2

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

确定这一点，并将它们与保持不变的东西区分开来。
程序到一个接口，而不是一个实现。

支持对象组合而不是继承。

公共类主 {

    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{ Door 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 接口，可以在初始化 Door 实例的类 X 和类 A 中声明构造函数。

示例 ;

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");
            }
        };

     }



}