Java Lesson Plan: Primitive Variables
Introductory Java — Edwin M. Torralba
Lesson Plan
Java Primitive Variables
Subject: Introductory Java | Level: Beginner | Duration: 90 minutes | Java 17+
1. Motivation
Before students can write meaningful Java programs, they need to understand how Java categorizes
and stores data. Primitive variables are the most fundamental building block of any Java program —
they define how numbers, characters, and logical values are held in memory.
This lesson gives students an early, concrete success: by the end of 90 minutes, they will have written
a working Java class from scratch. That sense of accomplishment builds the confidence needed for
more abstract topics ahead (objects, collections, algorithms).
Understanding data types also prevents an entire class of common bugs — overflow, precision loss,
type mismatch — that frustrate beginners precisely because they are invisible without this foundational
knowledge.
Why this matters to students
Almost every program they will ever write — games, apps, data tools — stores values in
variables. Understanding why int and double are different, and why Java forces you to be
explicit about type, makes students better problem-solvers and helps them read compiler
error messages with confidence.
2. Learning Objectives
By the end of this lesson, students will be able to:
1. Name all 8 Java primitive types and describe their size and purpose.
2. Declare, initialize, and reassign primitive variables using correct Java syntax.
3. Identify and fix common errors: integer overflow, missing literal suffixes, type mismatch, and use
of uninitialized variables.
4. Choose the most appropriate primitive type for a given real-world scenario.
Page 1 of 8
Java Lesson Plan: Primitive Variables
Introductory Java — Edwin M. Torralba
3. Reference: The 8 Primitive Types
Use this table as the anchor for direct instruction and distribute as a student cheat sheet.
Type Size Range / Values Example Declaration
byte 8-bit -128 to 127 byte age = 25;
short 16-bit -32,768 to 32,767 short year = 2024;
int 32-bit -2.1B to 2.1B int score = 9500;
long 64-bit ~-9.2 to 9.2 quintillion long pop = 8100000000L;
float 32-bit ~6-7 decimal digits float temp = 36.6f;
double 64-bit ~15-16 decimal digits double pi = 3.14159;
char 16-bit Unicode character char grade = 'A';
boolean 1-bit true or false boolean alive = true;
Key literal suffixes to emphasize
long: append L (e.g. 100L) | float: append f (e.g. 3.14f) | char: use single quotes (e.g. 'A')
| double: default for decimals — no suffix needed
4. Lesson Timeline (90 minutes)
Time Phase Type Activity
0–10 min Warm-Up Discussion What is data? Game character brainstorm.
10–25 Direct Instruction Lecture Introduce all 8 types with live IDE demo.
min
25–40 Guided Practice Activity Spot the Bug — 6 error-identification snippets.
min
40–65 Hands-On Lab Coding Build a Player Profile class in Java.
min
65–75 Concept Bridge Lecture Primitives vs. wrapper classes, autoboxing
min preview.
75–90 Exit Ticket Assessment 4-question formative check; class review.
min
5. Scaffolding Instructions
Effective scaffolding for this lesson moves students from observation to guided practice to independent
production. Each phase below includes explicit support structures.
Page 2 of 8
Java Lesson Plan: Primitive Variables
Introductory Java — Edwin M. Torralba
5.1 Warm-Up: Activate Prior Knowledge (0–10 min)
Begin with a question students can answer from lived experience, not prior Java knowledge:
Prompt to display on the board
"Think about a video game character. What information does the game need to remember
about them? Name as many things as you can."
Facilitate a 3-minute class brainstorm. Write responses on the board and then guide students to
classify them:
• Whole numbers (health, level, score) → integer types
• Decimal numbers (distance, weight, speed) → floating-point types
• Single letters (grade, category) → char
• Yes/no decisions (is alive, has key) → boolean
• Names, messages → note that these are Strings, not primitives — a preview
Bridge statement: "Java needs to know the type of every value before it can store it. Today we learn the
8 built-in types Java uses for simple values."
5.2 Direct Instruction: The 8 Types (10–25 min)
Use the "container size" analogy throughout: a byte is a small cup that holds only a little; a long is a
large bucket. Bigger containers cost more memory but hold more data.
Introduce types in this order:
• Integer family first: byte → short → int → long (show sizes increasing)
• Decimal family: float → double (emphasize precision difference)
• Character: char (show ASCII table; relate to int since char is numeric)
• Boolean last: simplest type, but critical for control flow
Live code examples to type with students:
int health = 100;
double speed = 9.81;
char grade = 'A';
boolean isAlive = true;
long worldPopulation = 8100000000L;
float temperature = 36.6f;
Scaffolding supports during instruction:
• Display the reference table (Section 3) on the projector throughout
• Ask check questions after each type: "What would happen if I stored 200 in a byte?"
• Call on students to predict output before running code
Page 3 of 8
Java Lesson Plan: Primitive Variables
Introductory Java — Edwin M. Torralba
5.3 Guided Practice: Spot the Bug (25–40 min)
Display each buggy snippet one at a time on the projector. Students work in pairs for 90 seconds, then
one pair shares. The class votes agree/disagree before the fix is revealed.
Six bugs to include:
• Bug 1 — Overflow: int x = 2147483648; (exceeds int max — should be long)
• Bug 2 — Missing suffix: float pi = 3.14; (needs f suffix)
• Bug 3 — Wrong quotes: char c = "A"; (char uses single quotes)
• Bug 4 — Uninitialized: int y; [Link](y); (variable never assigned)
• Bug 5 — Type mismatch: boolean flag = 1; (Java booleans are not integers)
• Bug 6 — Missing L suffix: long pop = 9000000000; (literal defaults to int, overflows)
Scaffolding tip
For students who struggle to spot the error, provide a hint card with three categories to
check: (1) Is the value too large for the type? (2) Does the literal have the right suffix or
quotes? (3) Has the variable been assigned before use?
5.4 Hands-On Lab: Build a Player Profile (40–65 min)
Students write a Java class that stores multiple attributes of a game character using an appropriate
primitive for each field. This is the core independent practice of the lesson.
Required fields:
• playerName — String (introduce as non-primitive; no need to go deep)
• health — int
• stamina — float
• level — short
• isAlive — boolean
• gradeLetter — char
Extension tasks (built into the lab for pacing):
• Print all values using [Link]
• Demonstrate overflow: set health = Integer.MAX_VALUE + 1 and observe the result
• Advanced: use Integer.MAX_VALUE and Integer.MIN_VALUE to print type limits
Scaffolding levels during the lab:
• Novice support: provide a skeleton class with method signatures and comments indicating
where each variable goes
• Standard: blank file; students work from their notes and the reference table
Page 4 of 8
Java Lesson Plan: Primitive Variables
Introductory Java — Edwin M. Torralba
• Advanced: add a second class that uses wrapper types (Integer, Boolean) and compare with ==
vs .equals()
Pair programming note
Encourage driver/navigator pairing. The driver types; the navigator watches for syntax
errors. Switch roles halfway through the lab. This structure reduces anxiety for students who
are slower typists and increases engagement for both.
5.5 Concept Bridge: Primitives vs. Wrapper Classes (65–75 min)
This is a brief conceptual preview, not a deep dive. The goal is to plant the idea before it becomes a full
lesson.
• Show: Integer age = 25; alongside int age = 25;
• Explain: wrapper classes let you treat a primitive as an object (needed for collections like
ArrayList)
• Demonstrate autoboxing: Integer x = 5; (Java wraps it silently)
• Key takeaway: always use the lowercase primitive unless you have a specific reason not to
Common misconception to address
Students often think String is a primitive because it is used so commonly. Clarify explicitly:
String is a class, not a primitive. It starts with a capital letter as a signal. The 8 primitives all
start with lowercase.
5.6 Differentiation Summary
Novice Standard Advanced
Types covered int, double, boolean, All 8 types All 8 + wrapper classes
char
Reference sheet Filled in (provided) Headers only None
Lab task Skeleton class provided Full lab as described Lab + type limits +
wrappers
Bug activity 3 bugs with categories All 6 bugs All 6 + write 2 own bugs
6. Assessment
Assessment in this lesson is layered: formative checkpoints throughout the session, performance-
based evidence from the lab, and a worksheet that yields concrete written artifacts.
Page 5 of 8
Java Lesson Plan: Primitive Variables
Introductory Java — Edwin M. Torralba
6.1 Assessment Overview
Assessment Category Criteria Timing
Exit Ticket Formative 4 short questions (type identification, error End of class;
fix, type selection) reviewed together
Spot the Bug Classwork 6 error identification items; written During guided
Worksheet explanation required practice
Player Profile Lab Grade Code runs correctly; overflow demo End of lab segment
Lab present; naming convention followed
Unit Quiz (next Summativ 10 MC + 2 short answer; covers all 8 types Start of next lesson
class) e and casting intro
6.2 Exit Ticket (Formative)
Distribute at the 75-minute mark. Students complete individually before the class review.
Exit Ticket — 4 Questions
Q1. Name a Java primitive type that can store the value 9,000,000,000. Why does int not
work? Q2. Write a valid Java declaration for a char variable holding the letter K. Q3. The
following line causes a compiler error. What is wrong and how do you fix it? | float tax =
0.08; Q4. A programmer needs to store a bank account balance accurate to two decimal
places. Which primitive type should they use, and why?
Scoring guidance:
• Q1: Correct type (long) + explanation of int overflow = full credit; type only = half credit
• Q2: Must include single quotes and correct syntax (char k = 'K';)
• Q3: Missing f suffix; correct fix is float tax = 0.08f;
• Q4: double; reason should mention precision or decimal digits
Use exit ticket results to identify students who need re-teaching before the next lesson. Students who
answer all four correctly are ready for the casting and wrapper class follow-up.
6.3 Spot the Bug Worksheet (Classwork)
Collected at the end of the guided practice segment. Students must:
• Identify the error type (overflow, suffix, uninitialized, mismatch, quotes)
• Rewrite the corrected line of code
• Explain in one sentence why the original was wrong
Grading: 3 points per item (1 for identification, 1 for fix, 1 for explanation). 18 points total.
Page 6 of 8
Java Lesson Plan: Primitive Variables
Introductory Java — Edwin M. Torralba
6.4 Player Profile Lab (Lab Grade)
Assessed on the following criteria:
Criterion Points Notes
All 6 fields declared with correct type 20 Deduct 3 per incorrect
type
Code compiles and runs without errors 20 Must run on teacher
machine
All values printed to console 15 Missing output − 5 per
field
Overflow demonstration present and commented 25 Comment must
explain what
happened
Variable names follow camelCase convention 10 Deduct 2 per violation
Code is readable (consistent indentation) 10 Holistic judgment
6.5 Unit Quiz (Next Class)
Administered at the start of the following lesson as a summative check before type casting is
introduced.
10 Multiple Choice questions cover:
• Matching a type to its bit size
• Selecting the correct literal syntax (suffix, quotes)
• Predicting output when overflow occurs
• Choosing the best type for a described variable
• Identifying whether a type is primitive or a wrapper class
2 Short Answer questions:
• Write declarations for 4 variables described in plain English
• Explain in 2–3 sentences why Java uses multiple integer types rather than one universal
number type
Re-teaching trigger
If more than 30% of students score below 70% on the unit quiz, re-teach the integer family
using a visual number-line activity before proceeding to type casting. Focus especially on
the suffix rules (L and f) and the distinction between float and double precision.
7. Materials & Resources
Page 7 of 8
Java Lesson Plan: Primitive Variables
Introductory Java — Edwin M. Torralba
• IDE installed on all machines (IntelliJ IDEA Community or VS Code with Java extension)
• Java 17+ JDK configured on all machines
• Starter code skeleton file ([Link] — attached separately)
• Spot the Bug worksheet (printout or digital via Google Classroom)
• Primitive types reference sheet (Section 3 of this document)
• Exit ticket (printout or Google Form)
• Projector for live coding and snippet display
• Fallback: JDoodle or Replit (browser-based) if IDE setup fails
8. Next Lesson Preview
Next lesson: Type Casting & Wrapper Classes
Building directly on this lesson, students will learn implicit widening conversion (int →
double), explicit narrowing with cast syntax ((int) 3.9), the risk of data loss, and when to use
Integer vs int. The unit quiz from this lesson serves as the entry checkpoint.
Page 8 of 8