Ch 03: Primitives and References

Source: Head First Java, Second Edition | Pages: 83-104

🎯 Learning Objectives

Understanding variables, memory, and references

📚 Key Concepts

• Primitive types (int, boolean, etc.)

• Reference variables

• Object references vs primitives

• Arrays fundamentals

• Heap vs Stack memory

• Garbage collection intro

• null references

---

📖 Detailed Notes

1. Primitive types (int, boolean, etc.)

Essential concept for mastering Java and OOP.

Example:

Rabbit hopper = new Giraffe();

2. Reference variables

Essential concept for mastering Java and OOP.

Example:

int count;

3. Object references vs primitives

Essential concept for mastering Java and OOP.

Example:

of type X”, think of type and class as synonyms.  

4. Arrays fundamentals

Essential concept for mastering Java and OOP.

Example:

int x;
x = 234;
byte b = 89;
boolean isFun = true;
double d = 3456.98;
char c = ‘f’;
int z = x;
boolean isPunkRock;
isPunkRock = false;
boolean powerOn;
powerOn = isFun;
long big = 3456789;
float f = 32.5f;

5. Heap vs Stack memory

Essential concept for mastering Java and OOP.

Example:

int x = 24;  
byte b = x;  

6. Garbage collection intro

Essential concept for mastering Java and OOP.

Example:

int size = 32;	

7. null references

Essential concept for mastering Java and OOP.

Example:

char initial = ‘j’;	

---

💡 Important Points to Remember

• that a reference variable

• that the compiler won’t let you

• We have to

• When you see a statement like: “an object

• the ‘f’. Gotta have that

---

✅ Self-Check Questions

Test your understanding:

1. Can you explain the main concepts covered in this chapter?

2. Can you write code examples demonstrating these concepts?

3. Do you understand when and why to use these features?

4. Can you explain the benefits and tradeoffs?

🔄 Quick Revision Points

• Primitive types (int, boolean, etc.)

• Reference variables

• Object references vs primitives

• Arrays fundamentals

• Heap vs Stack memory

• Garbage collection intro

• null references

---

📝 Practice Exercises

1. Write your own code examples for each key concept

2. Modify existing examples to test edge cases

3. Explain concepts to someone else

4. Create a small project using these concepts

🔗 Related Chapters

Review related concepts from other chapters to build comprehensive understanding.

---

For complete details, diagrams, and all examples, refer to Head First Java Second Edition, pages 83-104.

Chapter 3: Know Your Variables — Study Notes

This chapter explores how Java manages data using Variables. It covers the two main types of variables (primitives and references), how they are stored in memory, and the rules for declaring them.

---

1. Variable Fundamentals

A variable is essentially a container (think of it as a "cup") that holds something. Every variable in Java must follow two strict rules:

• Must have a type: Java is a "strongly-typed" language. You cannot put a "Giraffe" value into a "Rabbit" variable.

• Must have a name: This name allows you to use and track the variable in your code.

---

2. Primitive Types

Primitives hold fundamental values as simple bit patterns. They come in different "cup sizes" depending on the data they need to store.

Type	Bit Depth	Value Range
boolean	JVM-specific	true or false
char	16 bits	0 to 65535
byte	8 bits	-128 to 127
short	16 bits	-32,768 to 32,767
int	32 bits	-2,147,483,648 to 2,147,483,647
long	64 bits	Extremely large range
float	32 bits	Floating point (use 'f' suffix, e.g., 3.2f)
double	64 bits	Large floating point (standard default)

---

3. Object Reference Variables

There is no such thing as an "object variable." There are only object reference variables.

• The Remote Control Analogy: Think of a reference variable as a remote control to an object.

• Storage: While the reference variable lives on the Stack (if it's a local variable), the actual object always lives on the Heap.

• Reference Value: The "bits" inside a reference variable represent a way to get to a specific object on the heap.

Example:

Java

Dog myDog = new Dog();

1. Dog myDog: Declares a reference variable (the remote control).

2. new Dog(): Creates a new Dog object on the Heap.

3. =: Links the reference variable to the new object.

---

4. Array Variables

An array is an object, even if it is an array of primitives.

• Declaration: int[] nums; (declares a reference to an array).

• Creation: nums = new int[7]; (creates an array object that can hold 7 ints).

• Access: Use the index starting at 0 (e.g., nums[0] = 6;).

---

5. Memory Management: The Heap and The Stack

• The Stack: Where method calls and local variables live. When a method is called, its "stack frame" is pushed onto the stack. When it finishes, the frame is popped off, and all local variables in that frame die.

• The Heap: Where all objects live.

• Garbage Collection (GC): An object is eligible for GC when it has no more "live" references. This happens if:

  1. The reference goes out of scope.

  2. The reference is assigned to another object.

  3. The reference is explicitly set to null.

---

6. Revision Checklist

• Naming Rules: Variables must start with a letter, underscore (_), or dollar sign ($); they cannot start with a digit.

• Type Safety: You cannot assign a large type (like long) to a smaller type (like int) without an explicit cast, as this could cause "spillage".

• Primitive vs. Reference: Remember that primitives hold the actual value, while references hold the address of the object.

• Wrapper Classes: If you need to treat a primitive like an object (e.g., for an ArrayList), use its Wrapper class (e.g., Integer for int).