Types
editTypes
editA type is a classification of data used to define the properties of a value. These properties specify what data a value represents and the rules for how a value is evaluated during an operation. Each type belongs to one of the following categories: primitive, reference, or dynamic.
Primitive Types
editA primitive type represents basic data built natively into the JVM and is allocated to non-heap memory. Declare a primitive type variable or access a primitive type member field (from a reference type instance), and assign it a primitive type value for evaluation during later operations. The default value for a newly-declared primitive type variable is listed as part of the definitions below. A primitive type value is copied during an assignment or as an argument for a method/function call.
A primitive type has a corresponding reference type (also known as a boxed type). Use the field access operator or method call operator on a primitive type value to force evaluation as its corresponding reference type value.
The following primitive types are available:
|
8-bit, signed, two’s complement integer
|
|
16-bit, signed, two’s complement integer
|
|
16-bit, unsigned, Unicode character
|
|
32-bit, signed, two’s complement integer
|
|
64-bit, signed, two’s complement integer
|
|
32-bit, signed, single-precision, IEEE 754 floating point number
|
|
64-bit, signed, double-precision, IEEE 754 floating point number
|
|
logical quantity with two possible values of
|
Examples
-
Primitive types used in declaration, declaration and assignment.
-
Method call on a primitive type using the corresponding reference type.
Reference Types
editA reference type is a named construct (object), potentially representing multiple pieces of data (member fields) and logic to manipulate that data (member methods), defined as part of the application programming interface (API) for scripts.
A reference type instance is a single set of data for one reference type object allocated to the heap. Use the new instance operator to allocate a reference type instance. Use a reference type instance to load from, store to, and manipulate complex data.
A reference type value refers to a reference type instance, and multiple reference type values may refer to the same reference type instance. A change to a reference type instance will affect all reference type values referring to that specific instance.
Declare a reference type variable or access a reference
type member field (from a reference type instance), and assign it a reference
type value for evaluation during later operations. The default value for a
newly-declared reference type variable is null
. A reference type value is
shallow-copied during an assignment or as an argument for a method/function
call. Assign null
to a reference type variable to indicate the reference type
value refers to no reference type instance. The JVM will garbage collect a
reference type instance when it is no longer referred to by any reference type
values. Pass null
as an argument to a method/function call to indicate the
argument refers to no reference type instance.
A reference type object defines zero-to-many of each of the following:
- static member field
- A static member field is a named and typed piece of data. Each reference type object contains one set of data representative of its static member fields. Use the field access operator in correspondence with the reference type object name to access a static member field for loading and storing to a specific reference type object. No reference type instance allocation is necessary to use a static member field.
- non-static member field
- A non-static member field is a named and typed piece of data. Each reference type instance contains one set of data representative of its reference type object’s non-static member fields. Use the field access operator for loading and storing to a non-static member field of a specific reference type instance. An allocated reference type instance is required to use a non-static member field.
- static member method
- A static member method is a function called on a reference type object. Use the method call operator in correspondence with the reference type object name to call a static member method. No reference type instance allocation is necessary to use a static member method.
- non-static member method
- A non-static member method is a function called on a reference type instance. A non-static member method called on a reference type instance can load from and store to non-static member fields of that specific reference type instance. Use the method call operator in correspondence with a specific reference type instance to call a non-static member method. An allocated reference type instance is required to use a non-static member method.
- constructor
- A constructor is a special type of function used to allocate a reference type instance defined by a specific reference type object. Use the new instance operator to allocate a reference type instance.
A reference type object follows a basic inheritance model. Consider types A and B. Type A is considered to be a parent of B, and B a child of A, if B inherits (is able to access as its own) all of A’s non-static members. Type B is considered a descendant of A if there exists a recursive parent-child relationship from B to A with none to many types in between. In this case, B inherits all of A’s non-static members along with all of the non-static members of the types in between. Type B is also considered to be a type A in both relationships.
Examples
-
Reference types evaluated in several different operations.
declare
List l
; allocateArrayList
instance →ArrayList reference
; implicit castArrayList reference
toList reference
→List reference
; storeList reference
tol
load from
l
→List reference
; implicit castint 1
todef
→def
calladd
onList reference
with arguments (def
)declare
int i
; load froml
→List reference
; callget
onList reference
with arguments (int 0
) →def
; implicit castdef
toint 1
→int 1
; addint 1
andint 2
→int 3
; storeint 3
toi
-
Sharing a reference type instance.
declare
List l0
; allocateArrayList
instance →ArrayList reference
; implicit castArrayList reference
toList reference
→List reference
; storeList reference
tol0
declare
List l1
; load froml0
→List reference
; storeList reference
tol1
(notel0
andl1
refer to the same instance known as a shallow-copy)load from
l0
→List reference
; implicit castint 1
todef
→def
calladd
onList reference
with arguments (def
)load from
l1
→List reference
; implicit castint 2
todef
→def
calladd
onList reference
with arguments (def
)declare
int i
; load froml0
→List reference
; callget
onList reference
with arguments (int 0
) →def @0
; implicit castdef @0
toint 1
→int 1
; load froml1
→List reference
; callget
onList reference
with arguments (int 1
) →def @1
; implicit castdef @1
toint 2
→int 2
; addint 1
andint 2
→int 3
; storeint 3
toi
; -
Using the static members of a reference type.
Dynamic Types
editA dynamic type value can represent the value of any primitive type or
reference type using a single type name def
. A def
type value mimics
the behavior of whatever value it represents at run-time and will always
represent the child-most descendant type value of any type value when evaluated
during operations.
Declare a def
type variable or access a def
type
member field (from a reference type instance), and assign it any type of value
for evaluation during later operations. The default value for a newly-declared
def
type variable is null
. A def
type variable or method/function
parameter can change the type it represents during the compilation and
evaluation of a script.
Using the def
type can have a slight impact on performance. Use only primitive
types and reference types directly when performance is critical.
Errors
-
If a
def
type value represents an inappropriate type for evaluation of an operation at run-time.
Examples
-
General uses of the
def
type. -
A
def
type value representing the child-most descendant of a value.declare
Object l
; allocateArrayList
instance →ArrayList reference
; implicit castArrayList reference
toObject reference
→Object reference
; storeObject reference
tol
declare
def d
; load froml
→Object reference
; implicit castObject reference
todef
→def
; storedef
tod
;load from
d
→def
; implicit castdef
toArrayList reference
→ArrayList reference
; callensureCapacity
onArrayList reference
with arguments (int 10
); (notedef
was implicit cast toArrayList reference
since ArrayList` is the child-most descendant type value that thedef
type value represents)
String Type
editThe String
type is a specialized reference type that does not require
explicit allocation. Use a string literal to directly
evaluate a String
type value. While not required, the
new instance operator can allocate String
type
instances.
Examples
-
General use of the
String
type.
void Type
editThe void
type represents the concept of a lack of type. Use the void
type to
indicate a function returns no value.
Examples
-
Use of the
void
type in a function.void addToList(List l, def d) { l.add(d); }
Array Type
editAn array type is a specialized reference type where an array type instance
contains a series of values allocated to the heap. Each value in an array type
instance is defined as an element. All elements in an array type instance are of
the same type (element type) specified as part of declaration. Each element is
assigned an index within the range [0, length)
where length is the total
number of elements allocated for an array type instance.
Use the new array operator or the
array initialization operator to allocate an
array type instance. Declare an array type variable or
access an array type member field (from a reference type instance), and assign
it an array type value for evaluation during later operations. The default value
for a newly-declared array type variable is null
. An array type value is
shallow-copied during an assignment or as an argument for a method/function
call. Assign null
to an array type variable to indicate the array type value
refers to no array type instance. The JVM will garbage collect an array type
instance when it is no longer referred to by any array type values. Pass null
as an argument to a method/function call to indicate the argument refers to no
array type instance.
Use the array length operator to retrieve the length
of an array type value as an int
type value. Use the
array access operator to load from and store to
an individual element within an array type instance.
When an array type instance is allocated with multiple dimensions using the
range [2, d]
where d >= 2
, each element within each dimension in the range
[1, d-1]
is also an array type. The element type of each dimension, n
, is an
array type with the number of dimensions equal to d-n
. For example, consider
int[][][]
with 3 dimensions. Each element in the 3rd dimension, d-3
, is the
primitive type int
. Each element in the 2nd dimension, d-2
, is the array
type int[]
. And each element in the 1st dimension, d-1
is the array type
int[][]
.
Examples
-
General use of single-dimensional arrays.
declare
int[] x
; store defaultnull
tox
declare
float[] y
; allocate1-d float array
instance withlength [10]
→1-d float array reference
; store1-d float array reference
toy
declare
def z
; allocate1-d float array
instance withlength [5]
→1-d float array reference
; implicit cast1-d float array reference
todef
→def
; storedef
toz
load from
y
→1-d float array reference
; storefloat 1.0
toindex [9]
of1-d float array reference
load from
y
→1-d float array reference @0
; load fromindex [9]
of1-d float array reference @0
→float 1.0
; load fromz
→def
; implicit castdef
to1-d float array reference @1
→1-d float array reference @1
; storefloat 1.0
toindex [0]
of1-d float array reference @1
-
General use of a multi-dimensional array.
declare
int[][][] ia
; allocate3-d int array
instance with length[2, 3, 4]
→3-d int array reference
; store3-d int array reference
toia3
load from
ia3
→3-d int array reference
; storeint 99
toindex [1, 2, 3]
of3-d int array reference
declare
int i
; load fromia3
→3-d int array reference
; load fromindex [1, 2, 3]
of3-d int array reference
→int 99
; storeint 99
toi