Cooking with Code: Primitive Data Types in Apex and Java

Thinking about variables makes me hungry. That might be taking things a little far, but I’ve been preoccupied with cooking and coding recently, so they seem to be merging in my mind. I think this stuff can be fun, and for me, silly analogies make it all easier to understand. Hopefully by the end of this post you’ll agree!

My goal today is to provide an overview of primitive data type variables using examples from both Java and Apex. And of course, get some cooking-related metaphors in there while I’m at it.

(Note, so as not to confuse things further, all code below uses Apex syntax.)

Before I talk about variables with primitive data types, it would probably be helpful to talk about what a variable actually is.

What are variables?

You can think about a variable as a container in which stuff can be stored; kind of like those handy kitchen storage containers. They come in different sizes to store different types of things.

To illustrate this, think about the following scenario:On Monday night, you cook and use a container to store your leftovers. On Tuesday, once you’ve eaten the leftovers, then you can re-use the container for storing other items.

Variables are similar. They store things. Things otherwise known as values. They can be emptied and you can store another value in them.

So the variable is the container. We put something in it by assigning a value to the variable.
For example, in the following piece of code, I’ve highlighted the variable name in green on the left and the value in blue on the right:

What we’ve done here is:

Create (declare) a variablecalled myContainer, and

Give (assign) it a value of ‘Leftovers from Monday’. We’ve done this using an assignment operator, which is a fancy title for the “=”

Giving something a value, is also called assigning a value or initializing the variable.

But what’s with the bit in orange…what’s that all about?

All variables need to have two things.* The first is a name, e.g., myContainer, and the second is a data type, e.g., in our example myContainer is a variable of the String datatype.

*If they are to be happy and useful variables, then they also need a value, e.g., ‘Leftovers from Monday,’ but technically you can create a new variable without giving it a value.

The data type is always stated before the variable name. The following are all valid ways to create a variable:

The last one is tricky, because we have created a variable “b” of the type Boolean, but we haven’t assigned it a value (initialized it). But that’s ok, you can do all of it at once, or you can first declare a variable (create it) and later initialize it (give it a value).

For example, the first two lines of non-comment code are the equivalent of the statement at the beginning of this post (note that comments start with //). For kicks, I’ve added a few more lines…see if you can understand what I’m doing with them.

// We first create the myContainer variable and declare it a String
String myContainer;
// We cook Monday night and fill our container with leftovers
myContainer = ‘Leftovers from Monday’;
// Tuesday rolls around and we eat the leftovers, or in other words,
// we “call a method” called eatContents and point it at our container. Yum!
eatContents(myContainer);
// Wednesday night, we cook again, and store our leftovers
// in our now empty container (Hopefully we cleaned it first! ewwwww!)
myContainer = ‘Leftovers from Wednesday’;

So, what about those data types?

In our kitchen storage container analogy, containers come in many shapes and sizes, just right for storing things large (e.g., a baked lasagna), small (e.g., half a lemon), and well…differently shaped (e.g., uncooked spaghetti).

In the same way, we have different variable data types to store different types of … you guessed it … data.

There are simple data types and complex ones, and this post will talk through the simple, or primitive, data types.

What makes a variable data type primitive?

The easiest way I’ve seen to explain what makes a data type “primitive” is to say that it can’t be broken down into a simpler data type component.

One way to think about this is using measuring cups.

If a recipe calls for 2/3 cup of sugar, try as you might, you will not find a 2/3 measuring cup. There isn’t one. Measuring cups are made for the primitive amounts you need for cooking (1/4 cup, 1/3 cup, 1/2 cup and 1 cup).

We don’t need a 2/3 measuring cup, because you would just use the 1/3 measuring cup twice.

What makes a variable data type non-primitive?

Another way to think about primitive data types is to compare them to non-primitive data types (e.g., lists, arrays, sets, collections etc.). A simple example of a non-primitive data type is a muffin baking pan.

We can create a muffinPan variable, which can hold multiple muffins (elements). Because of this we could refer to muffinPan as an array of muffins. Don’t get too hung up on the “array” part just yet, I’ll get into them in a future post; just think of arrays as list or group of things.

MuffinPan:

First muffin

Second muffin

Third muffin

Forth muffin …

Let’s simplify this and look at our muffin pan and muffins as a bulleted list.

In this written out list, the elements within muffinPan are actually Strings of characters. So we can break a List data type down into its component Strings. But we can’t break down a string into a smaller data type (thankfully there is no character data type).

Another way to say this is we have a List data type that contains four elements of the String data type. So in this way, Lists are non-primitive (can be broken down) and Stings are primitive (can’t be broken down).

There are some other distinctions for what makes a data type non-primitive, but that’s for another post. This is good enough for now. (Phew!)

Examples of primitive data types

I’m working with two languages right now (Java and Apex), so I wanted to compare and contrast the different primitive data types for both languages. This is great, because Apex is based on Java, and shares many of the same data types.

There are some exceptions:

Some data types exist in Java but not in Apex (e.g., Short), and others are in Apex, but not in Java (e.g., ID).

Some of the names for data types (and thus how you declare them) are different in Java than in Apex, e.g., “Int” and “Char” in Java equate to “Integer” and “String” in Apex.

The table below lists the various primitive data types in both Java and Apex, with examples in Apex of how you might declare a variable of that type and assign a value to it.

Java

Apex

Data Type

Description

Data Type

Description

Apex Code Examples

Boolean & Character Data Types

Boolean

Think of this as a yes/no question. It can store a value of true, false or null1

Used in numbers with a decimal point. Useful when working with fractional numbers but where you don’t need a great degree of precision.

Decimal

A number that includes a decimal point. Decimal is an arbitrary precision number. In Apex, currency fields are automatically assigned the type Decimal. Also Decimal has a lot of built-in methods and rounding options.2

Decimal dec = 22.2323;

Double

Also used when working with number that need to use a decimal point, but more accurate than a float. In Java, use double when working with currency.

Double

Also a number that includes a decimal point. From a really big negative number to a really big positive number2

Time currentTime = DateTime.now().time();currentTime would output as: 12:24:42:027Showing time in hours, minutes, seconds and milliseconds

1 – Null is actually the absence of a value, which shouldn’t be confused with an empty string or a zero, which represent actual values. I know…fun right?!

2 – I wish I could give a better explanation of when to use Decimal vs Double – the best I can say is if you want to store currency or percentages or need access to more methods and rounding options than are available for Doubles, then use Decimal. Otherwise use Double. I’ll addend this post if I find some better explanation (I’ve got my feelers out).

How does all this relate to Salesforce Field Types?

So you can see that we have quite a few basic building blocks to work with here. For those of you Salesforce Awesome Admins, we can equate the Apex data types to field types in Salesforce as follows:

Salesforce Field Type

Apex Data Type

Auto-Number

String

Checkbox

Boolean

Currency

By default, assigned as Decimal

Date

Date

Date/Time

DateTime

Email

String

Number

Integer or Double, depending on if you set the decimal places to Zero or more than zero when you create the field.

Percent

By default, assigned as Decimal

Phone

String

Text, Text (Encrypted),Text Area, Text Area (Long), Text Area (Rich)

String

URL

String

Wrapping things up

There is more I can say about primitive data types, but that’s about all I could possibly hope for anyone to read through. Together, we’ll circle back to this topic in the future when we discuss variables with non-primitive data types, like our pan of muffins example.