抽象类、接口、mixins

Question

有人可以向我解释一下抽象类、接口和mixins之间的区别吗？ 我之前在代码中使用过它们，但我不知道技术差异。

Answer 1

抽象类

抽象类是不被设计为实例化的类。 抽象类可以没有实现、部分实现或全部实现。 抽象类旨在允许其子类共享公共（默认）实现。 抽象类的（伪编码）示例如下

abstract class Shape {
    def abstract area();  // abstract (unimplemented method)
    def outline_width() = { return 1; }  // default implementation
}

所示 子类可能看起来像

class Rectangle extends Shape {
    int height = width = 5;
    def override area() = { return height * width; }  // implements abstract method
    // no need to override outline_width(), but may do so if needed
}

可能的用法

def main() = {
    Shape[] shapes = { new Rectangle(), new Oval() };
    foreach (s in shapes) {
        print("area: " + s.area() + ", outline width: " + s.outline_width());
    }
}

如果子类不重写未实现的方法，那么它也是一个抽象类。

接口

在一般计算机科学术语中，接口是暴露给客户端的程序的一部分。 公共类和成员是接口的示例。

Java 和 C# 有一个特殊的interface 关键字。 这些或多或少是一个没有实现的抽象类。 （常量、嵌套类、显式实现和访问修饰符有些棘手，我不打算深入讨论。）尽管“无实现”部分不再适合 Java，但他们添加了默认方法。 interface 关键字可以看作是接口概念的具体化。

回到 Shape 示例，

interface Shape {
    def area();  // implicitly abstract so no need for abstract keyword
    def outline_width();  // cannot implement any methods
}

class Rectangle implements Shape {
    int height = width = 5;
    def override area() = { return height * width; }
    def override outline_width() = { return 1; }  // every method in interface must be implemented
}

def main() = {
    Shape[] shapes = { new Rectangle(), new Oval() };
    foreach (s in shapes) {
        print("area: " + s.area() + ", outline width: " + s.outline_width());
    }
}

Java 和 C# 不允许具有实现的类的多重继承，但它们确实允许多个接口实现。 Java 和 C# 使用接口来解决以下语言中发现的致命钻石死亡问题允许多重继承（如果处理得当，这并不是那么致命）。

Mixin

Mixin（有时称为特征）允许抽象类的多重继承。 Mixin 没有多重继承所具有的可怕关联（由于 C++ 的疯狂），因此人们更愿意使用它们。 它们具有完全相同的致命钻石死亡问题，但支持它们的语言比 C++ 拥有更优雅的缓解方法，因此它们被认为更好。

Mixin 被誉为具有行为重用的接口， 更灵活接口，和更强大的界面。 您会注意到所有这些都包含术语interface，指的是Java 和C# 关键字。 Mixin 不是接口。它们是多重继承。 有了一个更漂亮的名字。

这并不是说 mixin 不好。 多重继承并不坏。 C++ 解决多重继承的方式是每个人都兴奋不已的问题。

继续看陈旧的 Shape 示例，

mixin Shape {
    def abstract area();
    def outline_width() = { return 1; }
}

class Rectangle with Shape {
    int height = width = 5;
    def override area() = { return height * width; }
}

def main() = {
    Shape[] shapes = { new Rectangle(), new Oval() };
    foreach (s in shapes) {
        print("area: " + s.area() + ", outline width: " + s.outline_width());
    }
}

您会发现这与抽象类示例没有区别。

额外的一点是，C# 从 3.0 版本开始就支持 mixin。 您可以使用接口上的扩展方法来完成此操作。 这是具有真实（！）C# 代码 mixin 风格的 Shape 示例

interface Shape
{
    int Area();
}

static class ShapeExtensions
{
    public static int OutlineWidth(this Shape s)
    {
        return 1;
    }
}

class Rectangle : Shape
{
    int height = 5;
    int width = 5;

    public int Area()
    {
        return height * width;
    }
}

class Program
{
    static void Main()
    {
        Shape[] shapes = new Shape[]{ new Rectangle(), new Oval() };
        foreach (var s in shapes)
        {
            Console.Write("area: " + s.Area() + ", outline width: " + s.OutlineWidth());
        }
    }
}

Answer 2

一般来说：

接口是一个指定操作的契约，但没有任何实现。 某些语言（Java、C#）内置了对接口的支持，而在其他语言中，“接口”描述了一种约定，如 C++ 中的纯虚拟类。

抽象类是一种指定至少一个操作但没有实现的类。 抽象类还可以提供其实现的某些部分。 同样，某些语言内置了对将类标记为抽象的支持，而在其他语言中它是隐式的。 例如，在 C++ 中，定义纯虚方法的类是抽象的。

mixin 是一个类，其设计目的是使子类中某些功能的实现变得更容易，但其本身并不设计为使用。 例如，假设我们有一个处理请求的对象的接口，

interface RequestHandler {
  void handleRequest(Request request);
}

也许通过累积请求来缓冲请求直到我们有一些预定的数量，然后刷新缓冲区会很有用。 我们可以使用 mixin 实现缓冲功能，而不需要指定刷新行为：

abstract class BufferedRequestHandlerMixin implements RequestHandler {
  List<Request> buffer = new List<Request>();

  void handleRequest(Request request) {
    buffer.add(request);

    if (buffer.size == BUFFER_FLUSH_SIZE) {
        flushBuffer(buffer);
        buffer.clear();
    }
  }

  abstract void flushBuffer(List<Request> buffer);
}

这样，我们就可以轻松编写一个请求处理程序，将请求写入磁盘、调用 Web 服务等，而无需重写每次都缓冲功能。 这些请求处理程序可以简单地扩展BufferedRequestHandlerMixin并实现flushBuffer。

mixin 的另一个很好的例子是 Spring 中的众多支持类之一，即。 HibernateDaoSupport 。

Answer 3

由于许多人已经解释了定义和用法，我只想强调重要的一点

接口：

1. 定义合约（最好是无状态的 - 我的意思是没有变量）
2. 用“具有”功能。
3. 声明公共常量变量（不可变状态）

抽象类：

1. 在几个密切相关的类之间共享代码。 它建立了“is a”关系。

2. 在相关类之间共享公共状态（可以在具体类中修改状态）

我用一个小例子来结束差异。

Animal 可以是一个抽象类。 Cat 和 Dog，扩展这个抽象类建立了“is a”关系。

猫 是一种动物

狗 是一种动物。

Dog 可以实现Bark接口。 那么狗具有吠叫的能力。

Cat 可以实现Hunt接口。 那么猫具有狩猎的能力。

人，不是动物，可以实现Hunt接口。 那么人类就有了狩猎的能力。

人与动物（猫/狗）没有关系。 但Hunt接口可以为不相关的实体提供相同的能力。

Mixin：

1. 如果您想要抽象类和接口的混合。 当您想要在许多不相关的类上强制执行新契约时特别有用，其中一些类必须重新定义新行为，而其中一些应该坚持通用实现。 在 Mixin 中添加通用实现，并允许其他类在需要时重新定义契约方法。

如果我想声明一个抽象类，我将遵循这两种方法之一。

1. 将所有抽象方法移至接口，我的抽象类实现该接口。

   接口 IHunt{ 
         公共无效 doHunting(); 
     } 
     抽象类 Animal 实现 IHunt{ 
   
     } 
     类 Cat 扩展了 Animal{ 
         公共无效 doHunting(){} 
     } 
     

相关SE问题：

有什么区别接口和抽象类之间？

Answer 4

对 Java 的引用以及提供 mixin 的抽象类示例具有误导性。
首先，Java默认不支持“mixins”。 在 Java 术语中，抽象类和 Mixins 变得令人困惑。

mixin 是类除了其“主要类型”之外还可以实现的一种类型，以指示它提供一些可选行为。 用 Java 术语来说，一个例子是实现可序列化的业务价值对象。

Josh Bloch 说 - “抽象类不能用于定义 mixins - 因为一个类不能有多个父类”（记住 Java 只允许一个“扩展”候选者）

寻找 Scala 和 Ruby 等语言来适当实现这一概念“混合”的

Answer 5

Joshua Bloch 在他的 Java 著作中对“Mixin”的含义进行了出色的定义。 同一本书的摘录：

“mixin 是一种类型
除了其“主要类型”之外，类还可以实现以声明它提供
一些可选的行为。 例如，Comparable 是一个 mixin 接口，
允许一个类声明其实例相对于其他实例是相互排序的
可比较的对象。 这样的接口称为 mixin，因为它允许
要“混合”到类型的主要功能中的可选功能。”

Answer 6

基本上，抽象类是具有一些具体实现的接口。 接口只是一个没有实现细节的契约。

如果您想在实现抽象类的所有对象之间创建通用功能，则可以使用抽象类。 遵守 OOP 的 DRY（不要重复自己）原则。

Answer 7

抽象类是一个类，它的所有成员都没有被实现，它们留给继承者去实现。它强制它的继承者实现它的抽象成员。
抽象类不能实例化，因此它们的构造函数不应该是公共的。]

这是 C# 中的一个示例：

    public abstract class Employee
    {
        protected Employee(){} 
        public abstract double CalculateSalary(WorkingInfo workingInfo);//no implementation each type of employee should define its salary calculation method.
    }

   public class PartTimeEmployee:Employee
  {
    private double _workingRate;
    public Employee(double workingRate)
    {
     _workingRate=workingRate;
    }
    public override double CalculateSalary(WorkingInfo workingInfo)
    {
      return workingInfo.Hours*_workingRate;
    }

}

接口是由类实现的契约。它只是声明实现类的成员的签名，并且它本身没有实现。我们通常使用接口来实现多态性，并解耦依赖的类。

下面是一个 C# 示例：

public interface IShape
{
int X{get;}
int Y{get;}
void Draw();
}

public class Circle:IShape
{
public int X{get;set;}
public int Y{get;set;}

public void Draw()
{
//Draw a circle
}
}

public class Rectangle:IShape
{
public int X{get;set;}
public int Y{get;set;}

public void Draw()
{
//Draw a rectangle
}
}