Start learning with our library of video tutorials taught by experts. Get started
Viewed by members. in countries. members currently watching.
Join author David Gassner as he explores Java SE (Standard Edition), the language used to build mobile apps for Android devices, enterprise server applications, and more. This course demonstrates how to install both Java and the Eclipse IDE and dives into the particulars of programming. The course also explains the fundamentals of Java, from creating simple variables, assigning values, and declaring methods to working with strings, arrays, and subclasses; reading and writing to text files; and implementing object oriented programming concepts.
In Java, you can represent numbers as either primitive values or as complex objects. I am going to start by showing you how you represent them as primitives and then show, how to convert them into complex objects when needed. A primitive data type is a simple value. It represents only a single value and not many. That's one of the big differences between primitive values and complex objects. A primitive always points to a single value. Primitive data types are stored in the fastest available memory, whereas complex objects are stored in heap memory.
When you are running an application, you won't see significant differences, but they do exist. Primitives can be used to represent numeric, logical, or single character values. They can't be used to represent strings, dates or other things that have to be represented as complete objects. Most of your numeric values will be declared as primitives. You will only need to use complex objects where you need to do conversions or you need to guarantee precision when doing certain kinds of calculations. When you declare a primitive data type, you spell the data type in all lowercase.
So for example int, i-n-t or byte would be spelled all lowercase. There are also classes with these names, but they will have an uppercase initial character. Here are the numeric primitive data types. The byte data type takes 8-bits and can represent numbers starting at -128 and going to a maximum of 127. The short integer takes 16-bits and has much greater range and the most commonly used integer data type int takes 32-bit to memory and has a minimum and maximum of over 2 million in each direction.
There is also a long integer. It takes twice the memory that an int does and should only be used when you are representing very large numbers. Then there are two primitives that can represent floating values. The float takes 32-bits and the double takes 64-bits. You'll see developers represent currency values frequently with doubles, but as I'll explain later typically, you will want to use a special class called BigDecimal for that sort of purpose. When you use primitives, you can set their values directly using literal representation of numbers.
For the first three primitive data types, byte, short, and int, the syntax of the number is pretty conventional. It's just a numeric value without any quotes. You can't include string values such as currency symbols or commas. When you get into the larger numbers, the long, the float, and the double, the syntax is a little different. For long values, a literal numeric should be followed with the letter l, for long. You can use either an upper or lowercase l, but because the lowercase usually looks a lot like a 1, typically developers will use the uppercase L. The float value takes a lowercase f and the double value, a lowercase d. Again, you could use uppercase, but most developers use lowercase for these.
If you don't put in those additional alphabetical characters, usually things will still work out okay, but what's happening internally, may surprise you. If you don't put in that additional alphabetical character into your code, the value will be cast, based on a set of rules, that Java follows, for example the 100 would be initially be cast a byte and then it would be up cast to the long. So you are actually taking more memory than necessary creating two values where only one is needed. So it's recommended that if you are explicitly using a literal to represent a long, a float or a double then use these characters.
In addition to the primitive data types for numbers, there are also a set of helper classes that are part of the Java Class Library. Each of these helper classes includes tools for converting and outputting numeric values. Here is a listing of the data types on the left and their matching helper classes on the right. For the most part the names match, byte is byte, short is short and so on and the only difference is the initial character. The primitive data type is all lowercase. The class name has an initial uppercase character.
The only difference is in the integer where the primitive Data Type is int and the name of the Helper Class is Integer with an uppercase I. The helper classes have all sorts of great tools in them and they are always available to your Java code. Here is an example. The Double class provides methods and other tools for converting and managing double values. Let's say you started off with a literal doubleValue of 156.5d and you assigned that to a primitive variable of doubleValue.
Well, in order to convert it, the first step would be to create an instance of the Double class. This would be the syntax. The data type has Double with an uppercase D, which means the helper class and not the primitive. I am constructing an instance of the Double class and passing in the primitive value. Now I can convert that value using a set of methods called byteValue, intValue, floatValue and toString. These are instance methods or class methods of the Double class.
We'll learn more about what that means in later videos, but for now just take it to mean that you can call these methods whenever you create an instance of the class. Because a doubleValue you can have more precision than say a byte or an int, calling this syntax will result in truncating the value. So the result of myIntValue would be simply 156. The result of myByteValue though because 156 exceeds the available range of a byte, would wrap around and you would actually end up with a negative number.
I'll show you examples of these in some of the codes samples. When you declare a number, using a primitive data type, if you don't set the value initially, it defaults to zero. So for example, here I am declaring a variable called myInt and I am setting it using the int data type. I am not including the equals assignment operator or an initial value and so the result is that myInt is initially assigned as 0. You'll see that this is true of all the primitive numerics.
Now when you get into complex objects instances of classes, the rules are different, but we'll talk about that later. There is one other major issue to know about when you are working with numbers. If your application requires numeric precision, when you are doing calculations or rounding, you shouldn't use primitives for this purpose. The problem is that primitive values are stored in memory in a way that can't guarantee that precision. Instead, you should use a class called BigDecimal especially when you are working with currency values and you need to do certain kinds of math, the BigDecimal class can help you guarantee that precision.
Here is an example of what can go wrong. Let's say that you are starting off with a primitive value, in this case a literal of 1115.37. I am going to create an instance of the BigDecimal class called payment and I am constructing it directly from that literal value and then I am going to output that value as a string. You might think you would see the value 1115.37 as a string, but in fact you are going to see something like this. The exact value is going to vary depending on your system, your processor and other variables, but internally the number is stored in a very surprising way.
So when you are working with currency values, it's strongly recommend that you construct your big decimals based on strings. This guarantees that you are talking about exactly the value you think you are talking about. Let's say for example that you start off with a double value once again of 1115.37. Before you create your instance of BigDecimal, you should first get a string representation of the number. This guarantees that any additional decimal values are truncated and you are only working with the value you want.
So the second line of code uses the Double class's toString method and converts to a value called ds, data-typed as a string. Now I construct the instances of BigDecimal based on the string and then output the value and now I get what I expect. We'll talk more about the BigDecimal class in a later video in the series. So that's a look at representing numeric values in Java. For most purposes, the primitive data types do a great job, but in many cases, you want to use the numeric helper classes that are part of the class library and specifically when you are working with currency values and doing calculations and rounding, you should look at the big decimal class.
There are currently no FAQs about Java Essential Training.
Access exercise files from a button right under the course name.
Search within course videos and transcripts, and jump right to the results.
Remove icons showing you already watched videos if you want to start over.
Make the video wide, narrow, full-screen, or pop the player out of the page into its own window.
Click on text in the transcript to jump to that spot in the video. As the video plays, the relevant spot in the transcript will be highlighted.