类型和类之间的区别是什么？

是什么使类型不同于类，反之亦然？

(在一般的语言不可知论意义上)

83467 次浏览
小开

类型在概念上是类的超集。在更广泛的意义上，类是类型的一种形式。

与类密切相关的是接口，它可以被看作是一种非常特殊的类——一种纯粹的抽象类。这些也是类型。

因此，“类型”也包括类、接口和大多数语言中的原语。像 dot-net CLR 这样的平台也有结构类型。

小开

类型包含数据的描述(即属性、操作等) ,

类是一种特定的类型——它是创建 物品实例的模板。

严格地说，类是一个特殊的概念，它可以被看作是一个包含描述对象某些方面的 元数据子集的包。

例如，在 C # 中可以找到接口和类。它们都是类型，但接口只能定义一些契约，不能像类那样实例化。

简单地说，同学们是用于封装对象的属性和行为的 特殊类型。

维基百科可以给你一个更完整的答案:

小开

我总是把“ type”看作是“ class”和“ Basic”的总称。

int foo; // Type is int, class is nonexistent.

MyClass foo; // Type is MyClass, class is MyClass

小开

以最快的方式来说明:

结构是类型，但结构不是类。

如您所见，Type 是一个“抽象”术语，不仅用于定义类，而且用于结构和基本数据类型，如 float、 int、 bool。

小开

Type 是所有可用对象模板或概念的总括术语。类就是这样一个对象模板。结构类型、整数类型、接口类型等也是如此。这些都是类型

如果您愿意，您可以这样看待它: 类型是父概念。所有其他概念: 类、接口、结构、整数等等都是从这个概念继承而来的

小开

我认为类型是你可以用一个特定的值做的事情的集合。例如，如果您有一个整数值，您可以将其添加到其他整数(或执行其他算术操作) ，或将其传递给接受整数参数的函数。如果您有一个对象值，您可以调用由其类定义的方法。

因为类定义了您可以对该类的对象做什么，所以类定义了一个类型。类不仅如此，因为它还提供了如何实现方法的描述(类型中没有隐含的内容) ，以及如何布局对象的字段。

还要注意，一个对象值只能有一个类，但它可能有多个类型，因为每个超类都提供了对象类中可用功能的一个子集。

因此，尽管对象和类型是紧密相关的，但它们实际上并不是一回事。

小开

类型 通常指的是基本值的分类——整数、字符串、数组、布尔值、空值等。通常，您不能创建任何新类型。

类 是指创建对象时与之关联的命名属性和方法集。您通常可以定义任意多的新类，尽管有些语言必须创建一个新对象，然后将方法附加到该对象上。

这个定义基本上是正确的，但是有些语言尝试过以各种方式组合类型和类，并得到了各种有益的结果。

小开

再加上另一个区别的例子: 在 C + + 中，你有指针和引用类型，它们可以引用类，但是它们本身并不是类。

Bar b; // b is of type "class Bar"
Bar *b2 = &b; // b2 is of type "pointer to Class Bar"
Bar &b3 = b; // b3 is of type "reference to Class Bar"
Bar *b4[7]; // b4 is of type "7-element array of pointers to Class Bar"
Bar ***b5; //b5 is of type "pointer to a pointer to a pointer to Class Bar"

请注意，只涉及一个类，但可以使用近乎无限数量的类型。在某些语言中，函数被认为是“第一类对象”，在这种情况下，函数的类型就是一个类。在其他情况下，函数的类型仅仅是一个指针。类通常具有能够保存数据以及对该数据进行操作的概念。

小开

有趣的问题。我认为 aku 的答案是正确的。以 java ArrayList类为例

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList类的一个实例被认为是它扩展的每个超类和它实现的每个接口的类型。因此，ArrayList类的实例具有 ArrayList、 RandomAccess、 Cloneable等类型。换句话说，值(或实例)属于一个或多个类型，类定义这些类型是什么。

小开

类型和类是相关的，但不完全相同。我认为类用于实现继承，而类型用于运行时替换。

这里 是一个解释 替代原理替代原理以及为什么子类和子类型并不总是相同的链接(例如在 Java 中)。在反变的 维基百科页面上有更多关于这种区别的信息。

小开
最佳答案

以下答案来自 Gof book (设计模式)

对象的 同学们定义 对象实现 定义对象的内部状态和 计划的执行情况 行动。

相比之下，一个物体的 Type 仅指其接口 -a 它可以处理的一组请求 回答。

一个对象可以有多种类型, 不同类别的物件 有相同的类型。

//example in c++
template<typename T>
const T & max(T const &a,T const &b)
{
return a>b?a:b;  //> operator of the type is used for comparison
}

Max 函数需要一个带有自己类型的 操作 > 类型作为它的一个接口，任何满足上述要求的类都可以用来为该类生成特定的 max < 特定类/原语类型 > 函数。

小开

不同的类可以描述相同的类型。

类型由以下部分组成:

  1. 操作 = 语法
  2. 操作描述 = 语义

类由以下部分组成:

  1. 操作 = 语法
  2. 实现(= 描述相同语义的各种实现)

一些注意事项:

  • 接口(如 Java)不是类型，因为它不描述语义(仅描述语法)

  • 子类不是子类，因为子类可以改变超类中定义的语义，所以子类不能改变超类的语义(见 Liskov代换原则，例如 这个 LSP 的例子)。

小开

我的想法和阿库的答案一致。

我将类视为构建对象的模板，而类型则是对这些对象进行分类并为我们提供接口的一种方式。

Python 还添加了元类，它们只是构建类的一种机制，与类构建对象的方式相同(而且，类和元类都是对象)。

对同一个问题的这个回答在我看来，在 lamba 的极限似乎是一个完美的解释。

小开

显然，由于有些具有类型系统的语言不是面向对象编程语言，因此 类型必须是比 同学们更广泛的概念

即使在 Java 这样的语言中，int也是一种(原语)类型，而不是一个类。

因此: 每个类都是一个类型，但不是每个类都是一个类。

小开

如果我们在 C # 上下文中思考这个问题，我们得到以下答案。

C # 型系统分为以下几类:

值类型:

  • 简单类型: 如 int、 long、 float 等。
  • 枚举类型
  • 结构类型
  • 可空类型

参考类型:

  • 类型
  • 接口类型
  • 数组类型
  • 委托类型

正如你所看到的，C # 中有许多类型，Class 只是其中之一。 只有一点很重要: C # 的类型系统是统一的，这样任何类型的值都可以被视为对象。C # 中的每个类型都直接或间接派生自对象类类型，而对象是所有类型的最终基类。通过将引用类型的值视为类型对象，引用类型的值被视为对象。值类型的值通过执行装箱和取消装箱操作被视为对象。

正如我所看到的，字体是一把伞，覆盖了很多项目，哪个类别是其中之一。

参考文献: CSahrp 语言规范文档，第4页

小开

灵感来自 维基百科。

按 类型理论计算;

  • 类型是一个抽象接口。
    类型通常代表名词，如人、地点或事物，或名词化的东西，

  • 同学们表示该类型的实现。
    它是一个具体的数据结构和子例程的集合

    不同的具体类可以生成相同抽象类型的对象(取决于类型系统)。

    * 例如，可以使用两个 课程实现 类型 Stack: SmallStack(对于小堆栈快速，但规模较小)和 ScalableStack(对于小堆栈规模较大但开销较高)。*

    类似地，一个给定的类可能有几个不同的 构造函数。

enter image description here

香蕉的例子。

  • Banana 类型代表香蕉的一般特性和功能。

  • ABCBanana和 XYZBanana 课程代表了生产香蕉的方法。
    (现实生活中不同的香蕉供应商，或者在视频游戏中表示和绘制香蕉的不同数据结构和功能)。

    然后，ABCBanana类可以生产特定的香蕉 实例 的 ABCBanana 同学们，它们将是 < em > < em > 类别 香蕉。

程序员为类型提供单个且仅有的实现并不罕见。在这种情况下，同学们名称通常与 类型名称相同。但是仍然有一个类型(如果需要，可以在接口中提取)和一个实现(实现单独的接口)构建类的实例(对象)。

小开

摘自以下 GoF 引文:

对象的 同学们定义了 对象实现 定义对象的内部状态和 计划的执行情况 行动。

相比之下，一个物体的 Type 只是指它的接口-the 它可以处理的一组请求 回答。

我想提供一个使用 Java 的例子:

public interface IType {
}


public class A implements IType {
public A{};
}


public class B implements IType {
public B{};
}

类 A和 B都实现接口，因此属于 IType类型。此外，在 Java 中，两个类都生成自己的类型(分别对应于它们的类名)。因此，类 A是类 A 还有 IType和类 B是类 B 还有 IType令人满意:

一个对象可以有多种类型, 不同类别的物件 有相同的类型。

子类和子类之间的区别可能也有助于理解这个问题:

Https://www.cs.princeton.edu/courses/archive/fall98/cs441/mainus/node12.html

小开

在 一般语言不可知论者意义上-同学们是 类型的 意识到。

通常，当这是该类型的 只有实现时，您可以在某些上下文中使用这两个术语来引用它。

相反，例如，在 C # 上下文中，同学们只是 类型概念(如原语、结构、指针等)的 更多 实施的 一。

小开

这个问题对我来说是个好问题，这使我深思熟虑。我敢说 Class 是一个编译时的东西，Type 是一个运行时的东西。我这样说是因为您编写的是类而不是类型。然后，编译器从类中创建类型，运行库使用类型创建对象的实例。

小开

C 语言中的类型，如 Int Float、 char 等，定义了可以用特定方法操作的数据。没那么复杂。比如对于 int 我可以加，减，再除。这些是 int 的方法(或操作)。类只是新类型的定义。我首先定义数据的样子。也许只有一点。也许是两个词，就像一个有着真实和虚构部分的情结。或者是这个复杂的东西309734325字节代表木星上一个奇怪粒子的原子构成。我不在乎。就像一个整数一样，我可以用这个新的数据类型来完成操作。在整数的情况下，我有加、减等。使用这种新的数据类型，我可以定义任何我认为有意义的操作。它们可能是加减法等等。但他们可能会添加其他东西。这些是我决定添加到类中的任何方法。

底线是，对于 C 中的类型，您有一个数据是什么的定义，即: 一个字节、字、浮点数、字符等。但是，任何这些也意味着什么操作是合法的，并将产生可靠的结果。

除了由您来定义接口和可接受的操作之外，类没有什么不同。该类定义了这些内容，当您在 Object 中实例化它时，它定义了对象的行为，就像类型定义定义操作整数时的行为一样。

类只是为您提供了定义新类型以及关于它们如何操作的所有东西的灵活性。

一旦定义了这个对象，每次我实例化一个类“ thingy”的对象时，它都具有我定义的数据结构和我所说的可以使用它执行的操作(方法)。类“ thingy”显然不过是 C + + 让我定义的一种新类型。

小开

在像 Haskell 这样的语言中，Class 的概念并不存在。它只有 Type。(和 类别。不要与 同学们混淆，类别更像是 Type 的抽象版本)。

Monad 是 类别。

class Monad m where
(>>=)  :: m a -> (  a -> m b) -> m b
(>>)   :: m a ->  m b         -> m b
return ::   a                 -> m a
fail   :: String -> m a

从(纯)函数式编程的角度来看，Type 比 Class 更基本，因为它的根可以追溯到 类型理论(例如，从 PTL 的角度来看，带类型和不带类型的 lambda 演算的行为完全不同) ，而 Class 实际上只是一个启用 OO 的构造。

在只支持 Type 而不支持 Class 的语言中，函数通常被视为第一类物件。

同时，当一种语言区分了 Type 和 Class 时，函数更像是二等公民，可以附加到 Object 等等。是的，通常您可以将一个函数附加到 Class 本身(也就是静态函数)。

小开

Type 是帮助编译器执行类型检查并确保变量具有适合操作的属性的编程构造。

类是引用它们的对象或变量可能具有的用户定义类型。这些也受到类型检查。


提交答案