含义类型，类，接口的？

Question

查找许多学者互换使用术语类型及类别。某些教科书覆盖基于对象模型盖术语接口也

可能有人请用简单的术语基于特别是在一般的面向对象的编程和C ++ /爪哇/面向对象的数据库解释这些。

Answer 1

A 型是告诉你什么其允许值和允许的操作是一块数据的分类。 （乎？）所有的编程语言都有类型，虽然打字学科差异很大，从一种语言到另一种。

A 类是一个特定的样在OOP语言类型，其与在语言本身特定的句法定义的（而不是，比方说，所谓的“原生类型”像Java的int或float或类似它们由适当的语言）来定义。一类是在存储器布局方面通常定义和数据（所谓的成员变量）和功能上它们的工作（所谓的编码成员函数或方法）。

这是接口 *被认为是一组给定类似的类型，但不指定可允许的值，存储器布局，等的部分的什么动作的类型必须实现一个规范

这是一个非常，非常，非常简要概述即是种几种语言的方法对这些简化的“平均的形式”。它忽略了一些边缘的情况下，事情像C ++的能力，使事情是一个接口和类之间的中途。它还忽略哪些类功能性语言，如Haskell的，因为破坏你的大脑更远不是目的在这里。 ;）

---

编辑以添加一些实例

下面是一些基于Java的像的声明，以帮助水泥的概念。

int myVariable1;

此可变myVariable1-是由在二进制补符号编码的32位带符号的整数值的天然（或原始）型。它有一个已知的范围（约-2十亿至+2十亿）和一组已知操作（乘法，加法，除法，模量，减法，各种转换，等）提供给它的。

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

下面myVariable2是通过在类 MyClass定义的类型。 MyClass定义了存储器布局（在这种情况下，二进制补表示法由两个32位带符号整数的），以及在单次操作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位整数，并且两个操作的存储器布局的类型。其中的一个操作的一个是它的必须因为整个implements MyInterface部分的实现。这样，任何公司预计，（抽象）MyInterface类型可以使用（混凝土）MyOtherClass类型，因为操作是保证在那里。另一种方法 - myNonInterfaceMethod()，并不会来自MyInterface的这样的东西，期待只有MyInterface不能使用它，因为它不知道它的存在。

---

<强>进一步 编辑者请求添加一些真实世界的东西

如果你曾经在一个程序中使用的整数值，浮点值，字符串或像这样的东西你已经使用的类型。类型可以说是计算的东西，我们所做的一切都是给定类型的值的操作。我将重点，因此，上的类和接口的OOP-特定概念。

你有你有一类潜在的数据数据和操作的任何时间。举个考试PLE，一个银行帐户。银行帐户将有，除其它外，账户号码，当前余额，交易限度等一类表示该（不好，只示出解释概念）可能看起来像这样：

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类型 - 但不要使用FLOATING POINT在现实世界中FINANCIAL CODE！）和交易限额（它本身就是一个int类型）。你也知道，你可以进行交易（所谓的创造性transaction），这将检查对交易限额的变化和修改平衡。 （这方面的一个真正的类将含有大量的更多，会含有大量的混淆保护的东西，我已经为教学目的删除。）

现在让我们假设你在其中有几种交易的，不只是银行账户更复杂的金融环境是。比方说，进一步你有一些代码，将处理事务不关心底层类型的具体细节。交易，也就是说，覆盖银行账户，脱机批处理程序应收账款账户等，而不是使之了解书中的每个交易的种类，我们可以做到这一点，而不是：

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类型可以同时使用您的BankAccount的情况，以及你ReceivablesAccount的实例。他们不必知道银行账户有交易限制，而应收款帐户不。他们不必了解数据的内部表示什么。他们不必知道任何事物的特殊情况。他们只需要知道一个名字（transaction()）功能，仅此而已。 （如果你想的这个更具体的真实世界的用法，看看如何在集合类，不提“为”循环，使用Java中的Iterable接口。）

Answer 2

在O.O.P说法是很常见的使用条款的类型和类互换，特别是在谈论像Java和/或C某些语言++时。

一般来说，当你定义一个类你实际上限定的类型模板下，从哪个对象的类型你定义的将被创建，和/或实例化。

界面的概念是多一点点复杂，当你定义一个接口的你基本上指定特定的方式来处理对象的任何类型的不使用它的。也就是说，你的对象必须实现来自一类接口。接口是通过指定不包含在原来的类/类型规范的其他行为，提高你的等级/类型的一种方式。

对于许多实用的目的，你可以把一个对象深入它的界面，好像它是接口类型的，这可能就是术语接口与术语类型互换使用。

请参阅后面抽象数据类型了解进一步洞察理论

Answer 3

就个人而言，我认为这是比较容易，如果你在具体的术语描述它理解。举例来说，假设我们要建立一个程序来跟踪库存的东西在厨房里。

大多数语言只知道之类的东西整数，字符和字节的约十分简单，原始的“类型”。我们完全可以利用这些基本类型来描述一个厨房的类型的东西。例如，可以构造字符阵列，其中阵列中的每个索引代表的东西的属性的阵列。像，也许，指数0代表的你想描述的东西“类型”。但是，当然，这种技术会得到非常复杂非常快。

因此，使用面向对象的技术，我们可以很容易地通过组合原始类型定义新的类型。你做这件事的方法是通过创建一个类定义。一类认为，作为一种新型的蓝图。

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

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

这是接口描述我们如何与内容进行交互。例如，我们希望在我们的厨房里创造的东西的清单。我们希望能够从我们的库存“添加”，我们的库存，“删除”的东西，也许“迭代”在我们的库存。该行动“添加”，“删除”和“迭代”适用于几乎任何物品的清单（不只是我们的库存）。 Java提供了一个名为“列表” 接口这个目的。通过与非常流行和普遍列表“界面”创建一个清单对象，我们得到了所有的自由和其他程序员的动作可以看我们的节目，并确切地知道如何与“库存”对象交互：

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

因此，在上面的例子中，库存是包含类型ArrayList的实例变量。由于ArrayList类定义实现了“列表”界面，ArrayList类型的所有实例都必须服从于“列表”接口定义的合同。换句话说，我们可以有很容易地创建这样inventory作为链表（而不是一个ArrayList）：

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

记住把一个接口作为暴露的动作的特定集合来预先形成一合同。由于链表和ArrayList都实现了“列表”界面，它们都约定的义务，以实现在“列表”界面中的所有方法。

关于这个伟大的事情是，那有兴趣使用我们的“库存”变量的任何代码并没有给出关于如何“添加”或“删除”或“迭代废话“行动实施。他们所关心的是，变量“库存”服从“列表”界面。

在换言之，链表器具“添加”方法不是ArrayList的略有不同。但是，这并不重要的是要使用我们的“库存”变量的任何代码。

如果一些数学高手用革命的方式来存储列表中出现。也许他们弄清楚如何列表存储在月球上，而不是内部的计算机内存和原来是10倍比ArrayList的速度更快。然后，所有我们需要做的是这样的：

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.... 
}

当我们实例化这个类是一个对象，我们需要让编译器知道是什么类型的对象，它将会是。在这种情况下，我们的目标将是一种水果。

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

的代码前面的行告诉编译器来构造型果实的新对象。

因此，在简单的术语“类”定义了一个对象的特性（它的数据），其中，作为“类型”是指的是什么类型的对象，我们正在寻找在当它已被实例化，无论它是水果，租车，或台！

此概念可以经进一步读入继承性和多态性的主题展开。

我希望这是帮助。