类型、类、接口的含义？

Question

发现许多作者交替使用术语“类型”和“类”。某些涵盖基于对象模型的教科书也涵盖了术语“接口”。

有人可以根据面向对象编程，特别是 C++/Java/面向对象数据库，用简单的术语解释一下这些内容吗？

Answer 1

类型是一段数据的分类，告诉您其允许的值和允许的操作是什么。 （几乎？）所有编程语言都有类型，尽管一种语言与另一种语言的类型规则差异很大。

类是OOP语言中一种特殊的种类类型，它是用语言本身的特定语法定义的（与所谓的“本机类型”相反）例如 Java 的 int 或 float 等由语言本身定义的）。类通常根据内存布局和数据编码（所谓的成员变量）以及对其进行操作的函数（所谓的成员函数或方法）。

接口*是一个类型必须实现哪些操作才能被视为给定的一组相似类型的一部分的规范，但它没有指定允许的值、内存布局等。

这是一个非常非常，非常简短的概述，是几种语言处理这些问题的方法的简化“平均形式”。它忽略了一些边缘情况以及 C++ 能够创建介于接口和类之间的东西的能力。它还忽略了像 Haskell 这样的函数式语言中的类，因为进一步损害你的大脑并不是这里的目标。 ;)

---

编辑添加了一些示例

这里有一些类似的 Java 声明来帮助巩固概念。

int myVariable1;

此变量 - myVariable1 - 是本机（或原始）类型，由以 2 补码表示法编码的 32 位有符号整数值组成。它有一个已知的范围（大约-20亿到+20亿）和一组已知的可用运算（乘法、加法、除法、模数、减法、各种转换等）。

class MyClass
{
  int myMemberVariable;
  int myOtherMemberVariable;
  int myMethod(int p) { myMemberVariable += p; myOtherMemberVariable = p; }
}
MyClass myVariable2 = new MyClass();

这里myVariable2是由classMyClass定义的类型。 MyClass 定义内存布局（在本例中由两个 32 位有符号整数组成，采用 2 补码表示法）以及单个操作 myMethod()（将其添加到内存布局中）。 myMemberVariable 的参数，并将 myOtherMemberVariable 设置为该参数。

interface MyInterface
{
  int myInterfaceMethod(int p, int q);
}

这里 MyInterface 仅声明了一组操作（在本例中由单个函数 myInterfaceMethod() 组成），没有任何成员变量，也没有任何实现。它只是告诉您，任何实现此接口的类都保证具有具有名称+返回值+参数的特定签名的方法。要使用它，您必须创建一个实现该接口的类。

class MyOtherClass implements MyInterface
{
  int myMember1;
  int myMember2;
  int myMember3;
  int myInterfaceMethod(int p, int q) { myMember1 = p; myMember2 = q; myMember3 = p - q; }
  int myNonInterfaceMethod() { return myMember1; }
}
MyOtherClass myVariable3 = new MyOtherClass();

现在，myVariable3 被定义为一种类型，其内存布局由三个带符号的 32 位整数和两个操作组成。其中一项操作是它必须实现的，因为整个实现了MyInterface部分。这样，任何需要（抽象）MyInterface 类型的东西都可以使用（具体）MyOtherClass 类型，因为操作保证在那里。另一种方法 - myNonInterfaceMethod() - 不是来自 MyInterface，因此只需要 MyInterface 的方法无法使用它，因为它可以不知道它存在。

---

进一步编辑以根据请求添加一些现实世界的东西

如果您曾经在程序中使用过整数值、浮点值、字符串或类似的东西，使用过类型。类型可以说是计算的东西，我们所做的一切都是对给定类型的值的操作。因此，我将重点关注特定于 OOP 的类和接口的概念。

任何时候只要你有数据并对该数据进行操作，你就有可能成为一个类。以银行账户为例。除其他外，银行帐户将具有帐号、当前余额、交易限额等。表示此内容的类（很糟糕并且仅显示以解释概念）可能如下所示：

class BankAccount
{
  String accountNumber;
  float balance;  /* DO NOT USE FLOATING POINT IN REAL FINANCIAL CODE! */
  int transaction_limit;
  float transaction(float change) {
    balance += change > transaction_limit ? transaction_limit : change;
    return balance;
  }
}

现在您可以为此创建一个变量类型并知道它将携带一个帐号（它本身是一个 String 类型）、一个余额（它本身是一个 float 类型 - 但是 DON 'T 在现实世界金融代码中使用浮点！）和交易限额（其本身是 int 类型）。您还知道您可以执行一项交易（创造性地称为交易），该交易将根据交易限额检查更改并修改余额。 （一个真正的类将包含更多内容，并且包含许多令人困惑的保护内容，我出于教学目的而删除了这些内容。）

现在假设您处于一个更复杂的金融环境中，其中存在多种交易，不仅仅是银行账户。进一步说，您有一些代码可以处理不关心底层类型的具体情况的事务。例如，交易的离线批处理处理器，涵盖银行账户、应收账款账户等。我们可以这样做，而不是让它了解书中的每种交易：

interface Transactable
{
  float transaction(float change);
}

class BankAccount implements Transactable
{
  /* interior is identical */
}

class ReceivablesAccount implements Transactable
{
  float balance;
  float transaction(float change) { balance += change; }
}

现在任何了解 Transactable< /code> 类型可以使用您的 BankAccount 实例以及 ReceivablesAccount 实例。他们不必知道银行账户有交易限额，而应收账款账户则没有。他们不必了解有关数据内部表示的任何信息。他们不必了解任何事情的特殊情况。他们只需要知道一个函数的名称 (transaction())，仅此而已。 （如果您想更具体地使用它，请查看集合类（更不用说“for in”循环）如何使用 Java 中的 Iterable 接口。）

Answer 2

在 OOP 术语中，交替使用术语“类型”和“类”是很常见的，尤其是在谈论 Java 和/或 C++ 等语言时。

一般来说，当您定义一个类时，您实际上是在定义一个类型模板，从中将创建和/或实例化您所定义的类型的对象。

接口的概念有点复杂，当您定义接口时，您基本上是在指定一种特定的方式来处理使用它的任何类型的对象。也就是说，您的对象必须来自实现该接口的类。接口是一种通过指定原始类/类型规范中未包含的附加行为来增强类/类型的方法。

出于许多实际目的，您可以将对象彻底视为其接口，就好像它是接口类型一样，这可能就是术语接口与术语类型互换使用的原因。

如需进一步了解，请参阅抽象数据类型背后的理论。

Answer 3

我个人觉得如果具体描述一下的话会更容易理解。例如，假设我们想要构建一个程序来跟踪厨房中物品的库存。

大多数语言只知道非常简单、原始的“类型”，例如整数、字符和字节。我们完全可以使用这些原始类型来描述厨房中事物的类型。例如，您可以构造一个字符数组的数组，其中数组中的每个索引代表某物的一个属性。就像，也许索引 0 代表你试图描述的事物的“类型”。但是，当然，这项技术很快就会变得非常复杂。

因此，使用面向对象的技术，我们可以通过组合原始类型轻松地定义新类型。这样做的方法是创建一个类定义。将类视为新类型的蓝图。

在厨房示例中，我们有“食物”类型、“电器”类型和“家具”类型的概念。为了在程序中使用这些新类型，我们需要为每个类型创建一个类定义：

public class Food {...}
public class Appliance {...}
public class Furniture {...}

接口描述了我们如何与某些东西交互。例如，我们想要创建厨房中物品的库存。我们希望能够“添加”到我们的库存，从我们的库存中“删除”东西，也许还可以“迭代”我们的库存。 “添加”、“删除”和“迭代”操作几乎适用于任何列表（不仅仅是我们的库存）。 Java 提供了一个名为 "List" 的接口，用于这个目的。通过使用非常流行和常见的列表“接口”创建一个库存对象，我们可以免费获得所有操作，其他程序员可以查看我们的程序并确切地知道如何与“库存”对象交互：

...
java.util.List inventory = new ArrayList(); 
...
//later in our program, we can interact with inventory
//  with any of methods on the list interface (because ArrayList "implements" List)
inventory.add(new Furniture("chair"));
inventory.add(new Appliance("refrigerator"));
inventory.add(new Food("ice cream"));
...

所以，在上面的示例中， inventory 是包含 ArrayList 类型实例的变量。由于 ArrayList 类定义实现了“List”接口，因此 ArrayList 类型的所有实例都必须遵守“List”接口中定义的约定。换句话说，我们可以像这样轻松地创建 inventory 作为 LinkedList（而不是 ArrayList）：

java.util.List inventory = new LinkedList();

记住将接口视为公开要执行的一组特定操作的契约。由于 LinkedList 和 ArrayList 都实现了“List”接口，因此它们在合同上都有义务实现“List”接口中的所有方法。

这样做的好处是，任何对使用“库存”变量感兴趣的代码都不会关心“添加”、“删除”或“迭代器”操作如何实施的。他们所关心的是变量“inventory”遵循“List”接口。

换句话说，LinkedList 实现的“add”方法与 ArrayList 略有不同。但这对于任何想要使用我们的“库存”变量的代码来说并不重要。

如果某个数学高手想出一种革命性的方式来存储列表。也许他们想出了如何在月球上而不是在计算机内存中存储列表，结果比 ArrayList 快 10 倍。那么我们需要做的就是：

java.util.List inventory = new CrazyMoonList();

所有其他使用库存的代码都可以保持完全相同，因为 CrazyMoonList 保证提供“添加”、“删除”等功能。

希望这有助于澄清概念！

Answer 4

类是对象的模板，对象是包含变量、属性和方法的用户定义的数据类型。

//defines a simple class describing all types of fruit
public class Fruit {
    //insert fields here...

    Fruit(){//constructor method
        //insert constructor code here... 
    }

    //insert class methods here.... 
}

当我们将此类实例化为对象时，我们需要让编译器知道它将是什么类型的对象。在本例中，我们的对象将是 Fruit 类型。

//The initialisation might look something like this. 
Fruit myFruit = new Fruit(); 

上一行代码告诉编译器构造一个 Fruit 类型的新对象。

所以简单来说，“类”定义了一个对象的特征（它的数据），而“类型”是指我们在实例化对象时所看到的对象类型，无论是水果、汽车还是桌子！

可以通过进一步阅读继承和多态性主题来扩展这个概念。

我希望这有帮助。