Question

我正在玩设计模式，目前我正在使用原型模式。这个模式让我很奇怪，为什么我需要这个模式的接口，没有接口我不能实现相同的功能？

我创建了两个例子，有人能解释我为什么需要这个界面吗？

接口示例：

这是我的界面类：

interface IWeapon
{
    IWeapon Clone();
}

我的具体课程：

class Rifle : IWeapon
{

    public IWeapon Clone()
    {
        return (IWeapon)this.MemberwiseClone();
    }

}

克隆过程

 //Create rifle
 Rifle rifle = new Rifle();
 rifle.Name = "M4A1";
 rifle.Rounds = 30;

 //Copy Rifle
 Rifle rifleCopy = (Rifle)rifle.Clone();

这是我在没有界面的情况下克隆的方式

public Rifle Clone()
{
   return (Rifle)this.MemberwiseClone();
}

有人可以解释一下使用带有接口的实现在没有接口的情况下的优势吗？

Answer 1

原型模式中的界面应该看起来更像这样：

interface ICloneable
{
    ICloneable Clone();
}

即。你没有使用界面将你的类标记为武器，你用它来标记它有一个Clone方法可以用来创建一个副本。

Answer 2

当你有同样的东西，但使用不同的方法来实现它时，接口很棒。

使用你的例子，假设我们有这样的东西......

public interface ILongRangeWeapon
{
    void Fire();
}

现在，假设你有这些课程......

public class Rifle : ILongRangeWeapon
{
    public void Fire()
    {
        // Pull the trigger
    }
}

public class NuclearMissile : ILongRangeWeapon
{
    public void Fire()
    {
        // Press the red button
    }
}

现在你可以在你的代码中使用ILongRangeWeapon，它用于触发它的机制并不重要，它只知道它可以触发。

更实际的应用是连接到互联网。有多种方式可以连接，调制解调器，局域网，wifi等。但是，你甚至不关心实例如何连接，你只是想要它连接。

有些纯粹主义者说你应该把一切都变成一个界面。我认为它增加了复杂性，只是为了增加复杂性而不需要它。作为开发人员，您可以决定是否应该使用接口。

Answer 3

interface的要点是为类定义一个通用且可执行的结构。

在您的示例中，优势并不明显，因为您只声明了一种IWeapon类型。当你开始创造不同的武器时，真正的优势在于。

IWeapon类用于定义您希望从每个武器中获得的东西，这样您创建的每个武器类都继承自IWeapon。

最终，根据您对方法的期望，它是可预测的。然而，这些方法所做的事情对于每种武器都是独一无二的。

一个例子：

interface IWeapon
{
    IWeapon Clone();
    Boolean HasAmmo();
    Int32 RoundInMagazine();
    Double GetCaliber();
    Fire();
    //etc.
}

//1st weapon
public class Shotgun : IWeapon
{
    private Int32 _ammo = 5;

    public void Clone()
    {
        return (IWeapon)this.MemberwiseClone();
    }

    public Boolean HasAmmo()
    {
        return _ammo > 0;
    }

    public Int32 RoundsInMagazine()
    {
        return _ammo;
    }

    public Double GetCaliber()
    {
        return 12.0;
    }

    public void Fire()
    {
        MessageBox.Show("bang!");
    }
}

//1st weapon
public class Rifle : IWeapon
{
    private Int32 _ammo = 30;

    public void Clone()
    {
        return (IWeapon)this.MemberwiseClone();
    }

    public Boolean HasAmmo()
    {
        return _ammo > 0;
    }

    public Int32 RoundsInMagazine()
    {
        return _ammo;
    }

    public Double GetCaliber()
    {
        return 5.56;
    }

    public void Fire()
    {
        MessageBox.Show("bang! bang! bang!");
    }
}

有了这个，我可以定义任意数量的武器，每个武器都会为我提供最低级别的内容。真正的优势在于每个方法都以自己独特的方式实现这些方法。

将接口视为一组相关类的模板。

Answer 4

假设你有一个方法：

public void CloneAndShoot(IWeapon weapon) {
    IWeapon cloned = weapon.clone();
    cloned.shoot();
}

现在，如果您的界面定义如下：

interface IWeapon {
    IWeapon clone();
    void shoot();
}

你的方法可以接受各种武器而不关心：

CloneAndShoot(new M16());
CloneAndShoot(new M4A4());

Answer 5

可能avoid subclasses of an object creator in the client application, like the abstract factory pattern does.

https://en.wikipedia.org/wiki/Prototype_pattern

原型模式，为什么我需要一个接口？

5 个答案: