Difference between class and type
Being new to Java, I'm confused between the concepts of class and type.
For example, should the object "Hello World!"
belong to the type String
or class String
? Or maybe both?
A class is a type. An interface is a type. A primitive is a type. An array is a type.
Therefore, every type is also either a class (including an enum constant), an interface, a primitive, or an array.
There are two distinct categories of types: primitive types and reference types:
- A variable of primitive type always holds a primitive value of that same type. Such a value can only be changed by assignment operations on that variable.
- A variable of reference type always holds the value of a reference to an object. All objects, including arrays, support the methods of class
Object
. The reference types are class types (including enum types), interface types, and array types.
Every piece of data has a type which defines its structure, namely how much memory it takes up, how it is laid out, and more importantly, how you can interact with it.
Examples of primitive types:
int
float
char
boolean
Examples of class types:
String
Integer
Boolean
ArrayList
StringBuilder
Examples of interface types:
Collection
List
Map
Serializable
Examples of array types:
int[]
String[]
Integer[][][]
Basically, anything that you can refer to as a variable has a type, and classes are a kind of a type.
More info here: http://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html
TLDR - Class is one of the Type in Java.
Note - To fully understand the answer, you must have a little idea about generics in Java.
To understand the difference let us first understand what a Type is in Java.
According to JLS SE 10 ,
There are two kinds of types in the Java programming language: primitive types (§4.2) and reference types (§4.3).
What is primitive Type ?
a) The integral types are byte, short, int, and long, whose values are 8-bit, 16-bit, 32-bit and 64-bit signed two's-complement integers, respectively, and char, whose values are 16-bit unsigned integers representing UTF-16 code units (§3.1).
b) The floating-point types are float, whose values include the 32-bit IEEE 754 floating-point numbers, and double, whose values include the 64-bit IEEE 754 floating-point numbers.
c) The boolean type has exactly two values: true and false.
Now , let us come to what is reference type ?
There are four kinds of reference types: class types (§8.1), interface types (§9.1), type variables (§4.4), and array types (§10.1).
Let us discuss one by one.
If you see how in JLS , Class is defined like this :
A class declaration specifies a new named reference type.
There are two kinds of class declarations: normal class declarations and enum declarations.
ClassDeclaration:
NormalClassDeclaration
EnumDeclaration
NormalClassDeclaration:
{ClassModifier} class TypeIdentifier [TypeParameters] [Superclass] [Superinterfaces] ClassBody
You see that [TypeParameters]
, this shows that class type includes those
generic classes too.
class Example<T>{
}
The class type will be called Example
In short , a class type covers our enums , our regular (non generic) classes like String
etc and our generic classes too.
Similarly , I hope interface and array types is also clear. By array Type we mean like int[]
, String[]
etc.
Let us come to the last part - Type variables. What are they ?
A type variable is an unqualified identifier used as a type in class, interface, method, and constructor bodies.
Let us understand by the example in the JLS below it.
class Test {
<T extends C & I> void test(T t) {
t.mI(); // OK
t.mCPublic(); // OK
t.mCProtected(); // OK
t.mCPackage(); // OK
}
}
You see that your object in the method parameter is of type T
. Yes , this T
is Type variable and is/can be used as a reference . Yes it is. (Could not understand this strange example - Learn what is generic method in Java)
This completes the answer.
"Type" is the more inclusive category. Variables in Java can have three kinds of types: the 8 "primitive" types like int and float, interfaces, and classes. Values (as opposed to variables) can be primitive or class instances.
"Type" defines 'what type of data it is'
Ex: "hello world" is a String --> "hello world" is String type (String is not a premetive data unlike int .. so we can say "hello world" is a string class type)
10 is a int --> 10 is a integer data type.