Why would we want to do this? Answer the question in this cell.
Answer
These classes convert primitive data types (int/double) to a reference data type (object). We convert these because different data structures in java require different types of variables, some of which are only objects. By parsing the values of the primitive data to an object, we can send values to methods and structures that only take object values, like ArrayList, for example.
The integer Wrapper Class
The Integer class in Java is a wrapper class for the primitive data type int. It provides several methods that can be used to perform operations on int values. The constructor looks like this:
Integer(int value)
| Integer(int value)
'.class' expected
An example of this running is:
Integer hungerRating = new Integer(5); // Send to an Object
int hungerRatingNum = hungerRating.intValue(); // Turn back into a primitive
An example of it being utilized is:
ArrayList<Integer> list = new ArrayList<Integer>(); // This will cause a compile-time error
The above code will not work because ArrayList requires on object type, while we are passing a primitive type.
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5); // Autoboxing will automatically convert the int 5 to an Integer object
System.out.println(list)
[5]
This code works because the 5 is being converted by the list.add, since the list uses integer objects.
Challenge: In the cell below, demonstrate a function failing with an int and a function succeding with an integer. This cannot be an ArrayList. You are NOT allowed to use ChatGPT, Google AI, Llama 2, Bing AI, etc, however, you can Google for answers.
Moreover, we can also get other data from the integer class, which is related to how Java functions.
System.out.println("Integer Min Value: " + Integer.MIN_VALUE);
System.out.println("Integer Max Value: " + Integer.MAX_VALUE);
Integer Min Value: -2147483648
Integer Max Value: 2147483647
These numbers are the bounds of integers in java. For example, we can try going outside the range to see what happens.
Integer pleaseBreak = new Integer(2147483648)
| Integer pleaseBreak = new Integer(2147483648);
integer number too large
Challenge: Can we have a primitive int that goes past that bound? Try and find out in the cell below.
Double Wrapper Classes
Double wrapper classes are basically the same thing as integer classes, however, they deal with double varaiables instead of integer variables. You write it like this:
Double(Double Value)
Here is an example of using Double object:
// My actual height in real life (in feet)
Double height = new Double(6.6); // Send to an Object
double primitiveHeight = height.doubleValue(); // Turn back into a primitive
And here is an example of when it works and when it does not.
ArrayList<double> list = new ArrayList<double>(); // This will cause a compile-time error
| ArrayList<double> list = new ArrayList<double>(); // This will cause a compile-time error
unexpected type
required: reference
found: double
| ArrayList<double> list = new ArrayList<double>(); // This will cause a compile-time error
unexpected type
required: reference
found: double
Again, the ArrayList needs an object type, but we are passing a primitive type.
ArrayList<Double> list = new ArrayList<Double>();
list.add(3.14); // Autoboxing will automatically convert the double 3.14 to a Double object
true
This code works because the 3.14 is being converted by the list.add, since the list uses double objects.
Autoboxing
Autoboxing is when Java automatically changes a basic data type into its object form. The Java compiler does this for us. Think of it as putting the data into a box. Java can also unbox an object, which is the exact opposite of autoboxing. When an Integer object is assigned to a primitive int type, Java will automatically use the primitive int version of the number and assign it to the int variable.
// Boxing
int a = 5;
Integer b = a;
// Unboxing
Integer x = new Integer(10);
int y = x;
2.9 Using the Math Class
Java has a built in math class called ___? It is a part of the java.lang class.
System.out.println(Math.abs(-5)) // Absolute Value
5
System.out.println(Math.pow(5, 2)) // Power: base, exponent
25.0
// Two ways to calculate square roots
System.out.println(Math.pow(25, 0.5)); // Allows for different roots
System.out.println(Math.sqrt(25)) // Square Root
5.0
5.0
Finally, arguably the most important class in math: The random class! Many purposes, especially in game development. What is one purpose?
System.out.println((int)Math.random()) // Always returns zero because the range of math.random is [0, 1)
0
In the cell below, experiment and try to figure out a way to call Math.random and impliment bounds, with your bounds being integer bounds of a and b.
function getRandomIntegerInRange(a, b) {
// Check if 'a' and 'b' are valid bounds
if (a >= b) {
throw new Error("Invalid bounds: 'a' must be less than 'b'");
}
// Calculate the difference between upper and lower bounds
const range = b - a;
// Generate a random number between 0 (inclusive) and 1 (exclusive)
const randomFraction = Math.random();
// Scale the random number to the desired range and add the lower bound
const randomInteger = Math.floor(randomFraction * range) + a;
return randomInteger;
}
// Example usage:
const lowerBound = 10;
const upperBound = 20;
const randomValue = getRandomIntegerInRange(lowerBound, upperBound);
console.log(randomValue); // This will print a random integer between 10 and 19.