What is the difference between Type and Class?

Question

The following answer is from Gof book (Design Patterns)

An object's class defines how the object is implemented. The class defines object's internal state and the implementation of its operations.

In contrast, an object's type only refers to its interface - a set of requests to which it can respond.

An object can have many types, and objects of different classes can have the same type.

//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 function requires a type with operation > with its own type as one of it interface any class that satisfies the above requirement can be used to generate specific max<particular class/primitive type> function for that class.

I always think of a 'type' as an umbrella term for 'classes' and 'primitives'.

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

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

Inspired by Wikipedia...

In type theory terms;

• A type is an abstract interface.
  Types generally represent nouns, such as a person, place or thing, or something nominalized,

• A class represents an implementation of the type.
  It is a concrete data structure and collection of subroutines

  Different concrete classes can produce objects of the same abstract type (depending on type system).

  *For example, one might implement the type Stack with two classes: SmallStack (fast for small stacks, but scales poorly) and ScalableStack (scales well but high overhead for small stacks).*

  Similarly, a given class may have several different constructors.

The banana example.

• A Banana type would represent the properties and functionality of bananas in general.

• The ABCBanana and XYZBanana classes would represent ways of producing bananas.
  (Different banana suppliers in real life, or different data structures and functions to represent and draw bananas in a video game).

  The ABCBanana class could then produce particular bananas which are instances of the ABCBanana class, they would be objects of type Banana.

It is not rare the programmer provide a single and only implementation for a type. In this case the class name is often identical with the type name. But there is still a type (which could be extracted in an interface if required), and an implementation (which would implement the separate interface) which builds instances (objects) of the class.

Type is the umbrella term for all the available object templates or concepts. A class is one such object template. So is the structure type, the Integer type, the Interface type etc. These are all types

If you want, you can look at it this way: A type is the parent concept. All the other concepts: Class, Interface, Structure, Integer etc inherit from this concept.i.e They are types

Taken from the GoF citation from below:

An objects's class defines how the object is implemented .The class defines the object's internal state and the implementation of its operations.

In contrast, an objects's type only refers to its interface - the set of requests to which it can respond.

I want to provide an example using Java:

public interface IType {
}

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

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

Both classes A and B implement the interface and thus are of the type IType. Additionally in Java, both classes produce their own type (respectively to their class name). Thus the class A is of type A and IType and the class B is of type B and IType satisfying:

An object can have many types, and objects of different classes can have the same type.

The difference between subtypes and subclass probably helps to understand that issue as well:

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

In general language-agnostic sense - Class is an realization of the Type.

Often when this is the only realization of that type, you can use both terms to reference it in some context.

On the contrary, for example, in C# context - Class is just one of the many more implementations of a Type concept like primitives, structs, pointers etc.