Obj 1: Handling date, time, text, numeric and boolean values

Question 1

Java primitive type

Answer 1

Java has eight built- in data types.
A primitive is not an object in Java,
nor does it represent an object. A primitive is just a single value in memory, such as a number
or character.

Question 2

What are the primitive types

Answer 2

boolean, byte, short, int, long, float, double, char

Question 3

default values of:
- boolean
- byte
- short
- int
- long
- float
- double
- char

Answer 3

• false
• 0
• 0
• 0
• 0L
• 0.0f
• 0.0
• \u0000 (nil)

Question 4

Does it compile
float x = 1.0 ;

Answer 4

No, a float requires the letter f or F following the number so Java knows it is a float. Without an f or F, Java interprets a decimal value as a double

Question 5

Does it compile
long x = 123000;

Answer 5

No, a long requires the letter l or L following the number so Java knows it is a long.
Without an l or L, Java interprets a number without a decimal point as an int in most
scenarios.

Question 6

short s = -123;
char c = (char) s;
Does it compile ?

Answer 6

Yes, short and char values can be cast to one another because the underlying data size is the same

Question 7

A number in the code is called …

Answer 7

literal

Question 8

long max = 3123456789;
Does it compile ?

Answer 8

No, Java complains the number is out of range.
The solution is to add the character L to the number:
long max = 3123456789L; // Now Java knows it is a long

Question 9

Does Java allow other decimal number system.

Answer 9

Yes, Java allows you to
specify digits in several other formats:
* Octal (digits 0–7), which uses the number 0 as a prefix— for example, 017.
* Hexadecimal (digits 0–9 and letters A–F/a–f), which uses 0x or 0X as a prefix— for
example, 0xFF, 0xff, 0XFf. Hexadecimal is case insensitive, so all of these examples
mean the same value.
* Binary (digits 0–1), which uses the number 0 followed by b or B as a prefix— for
example, 0b10, 0B10.

Question 10

double annoyingButLegal = 1_00_0.0_0;
does it compile ?

Answer 10

Yes, You can add underscores anywhere except at the beginning of a literal, the end of a literal, right before a decimal point, or right after a decimal point. You can even place multiple underscore characters next to each other.

Question 11

Each primitive type has a wrapper class, which is an object type that corresponds to the primitive.
- boolean
- byte
- short
- int
- long
- float
- double
- char

Answer 11

• Boolean
• Byte
• Short
• Integer
• Long
• Float
• Double
• Character
  Only Boolean and Character do not extend the class Number

Question 12

int x = 123;
Integer y = Integer.valueOf(x);

String str = “123”;
Integer wrapper = Integer.valueOf(str);
int primitive = Integer.parseInt(str);

does code compile ?

Answer 12

Yes
There is also a valueOf() variant that converts a String into the wrapper class

Question 13

String str = “””
Hello \s
World!”””;

String str = “””
Hello \
World!”””;

String str = “””
Hello \n
World!”””;

String str = “””
Hello \s World!”””;

String str = “””
Hello \nWorld!”””;

Answer 13

Hello
World! (2 lines)

Hello World! (1 line)

Hello

World! (3 lines)

Hello World! (1 line)

Hello
World! (2 lines)

Question 14

 int value = 3;                   // Stored as 0011
 int complement = ~value;         // Stored as 1100
 System.out.println(value);       // 3
 System.out.println(complement);  // - 4

how to find the bitwise complement of a number ?

Answer 14

multiply it by negative one and then subtract one.
```
System.out.println(-1value - 1); // - 4
System.out.println(-1complement - 1); // 3
~~~

Question 15

int pelican = !5;         
 boolean penguin = - true;  
 boolean peacock = !0;    

does it compile ?

Answer 15

No, you cannot apply a negation operator (- ) to a boolean expression, nor can you apply a logical complement operator (!) to a numeric expression.

Question 16

Tip

Answer 16

Keep an eye out for questions on the exam that use numeric values (such as 0 or 1) with boolean expressions. Unlike in some other programming
languages, in Java, 1 and true are not related in any way, just as 0 and false are not related.

Question 17

 int parkAttendance = 0;
 System.out.println(parkAttendance);    
 System.out.println(++parkAttendance); 
System.out.println(parkAttendance);    
System.out.println(parkAttendance--);  
 System.out.println(parkAttendance);   

guess the output of each System.out.println ?

Answer 17

 System.out.println(parkAttendance);    // 0
 System.out.println(++parkAttendance);  // 1
  System.out.println(parkAttendance);    // 1
 System.out.println(parkAttendance--);  // 1
 System.out.println(parkAttendance);    // 0

The first pre- increment operator updates the value for parkAttendance and outputs the new value of 1. The next post- decrement operator also updates the value of parkAttendance but outputs the value before the decrement occurs.

Question 18

 float egg = 2.0 / 9;        
 int tadpole = (int)5 * 2L;  
 short frog = 3 -  2.0;       

does this compile ?

Answer 18

No, Casting is optional and unnecessary when converting to a larger or widening data type, but it is required when converting to a smaller or narrowing
data type. Without casting, the compiler will generate an error when trying to put a larger data type inside a smaller one.

Casting primitives is required any time you are going from a larger numerical data type to a smaller numerical data type, or converting from a floating-point number to an integral value.

Question 19

byte hat = 1;
 byte gloves = 7 * 10;
 short scarf = 5;
 short boots = 2 + 1;
  short boots = 2 + hat;  
 byte gloves = 7 * 100; 

Which lines do not compile ?

Answer 19

The 5th statement does not compile because hat is a variable, not a value, and both operands are automatically promoted to int. When working with values, the compiler had enough information to determine the writer’s intent. When working with variables, though, there is ambiguity about how to proceed, so the compiler reports an error. The 6th expression does not compile because 700 triggers an overflow for byte, which has a maximum value of 127

Question 20

 long goat = 10;
 int sheep = 5;
 sheep = sheep * goat; 
``` 
 Does it compile ?
 
 ```
long goat = 10;
 int sheep = 5;
 sheep *= goat;

Does this compile ?

Answer 20

1. No, We are trying to assign a long value to an int variable. This last line could be fixed with an explicit cast to (int)
2. Yes, The compound operator will first cast sheep to a long, apply the multiplication of two long values, and then cast the result to an int. Unlike the previous example, in which the compiler reported an error, the compiler will automatically cast the resulting value to the data type of the value on the left side of the compound operator

Question 21

long wolf = 5;
 long coyote = (wolf=3);
 System.out.println(wolf);   // 3
 System.out.println(coyote); // 3

Answer 21

The key here is that (wolf=3) does two things. First, it sets the value of the variable wolf to be 3. Second, it returns a value of the assignment, which is also 3.

Question 22

 boolean healthy = false;
 if(healthy = true)
   System.out.print("Good!");

Answer 22

While this may look like a test if healthy is true, it’s actually assigning healthy a value of true. The result of the assignment is the value of the assignment, which is true, resulting in this snippet printing Good!

Question 23

var monday = new File("schedule.txt");
 var tuesday = new File("schedule.txt");
 var wednesday = tuesday;
 System.out.println(monday == tuesday);    
 System.out.println(tuesday == wednesday); 

Answer 23

1. false
2. true

Even though all of the variables point to the same file information, only two references, tuesday and wednesday, are equal in terms of == since they point to the same object.

Question 24

System.out.print(null == null);  

Answer 24

true, In some languages, comparing null with any other value is always false, although this is not the case in Java.

Question 25

 int gibbonNumFeet = 2, wolfNumFeet = 4, ostrichNumFeet = 2;
 System.out.println(gibbonNumFeet < wolfNumFeet);      // true
 System.out.println(gibbonNumFeet <= wolfNumFeet);     // true
 System.out.println(gibbonNumFeet >= ostrichNumFeet);  // true
 System.out.println(gibbonNumFeet > ostrichNumFeet);   // false

Answer 25

the last example outputs false, because although gibbonNumFeet and ostrichNumFeet have the same value, gibbonNumFeet is not strictly greater than
ostrichNumFeet