Introduction to Java Programming.
Chapter 1:
Introduction
1.9
Variables in Java: Containers for Data
Variables are fundamental programming
constructs that serve as named memory locations to store data values. They are
essentially containers that hold information, and importantly, the data they
hold can change (or vary) during the execution of a program. Understanding
how to declare, initialize, and effectively use variables is a core skill for
any Java programmer.
1.9.1 What
are Variables?
Definition: Named Memory Locations to Store
Data |:
In essence, a variable is a symbolic name given to a
storage area in a computer’s memory. When you declare a variable, you’re
telling the computer to reserve a specific amount of memory space and associate
a human-readable name with that space. This name then allows you to refer to
that memory location and the data stored within it.
Purpose: To Hold Data That Can Change During
Program Execution |:
The primary purpose of variables is to store data
that can be manipulated, processed, or updated as the program runs. For
example, in a game, a variable might store a player’s score, which increases or
decreases. In a banking application, a variable might hold an account balance
that changes with deposits and withdrawals. This dynamic nature of variables is
what makes programs interactive and capable of handling varying inputs and
states.
Analogy: Think of a variable as a labeled
box. The label is the variable’s name (e.g., age), and the contents inside the
box are the variable’s value (e.g., 25). You can open the box and change its
contents (change the value of age to 26), but the label on the box remains the
same.
1.9.2
Declaring Variables
Before you can use a variable, you must declare
it. Declaration involves specifying two main things: the data type of
the variable and its name. The data type tells Java what kind of values
the variable can hold (e.g., whole numbers, decimal numbers, text, true/false
values), which in turn determines how much memory to allocate for it.
Syntax: dataType variableName;
○
dataType: This refers to one of Java’s primitive data
types (like int, double, boolean,
char, byte, short, long, float) or a non-primitive/reference type (like String,
Scanner, or any custom class you define).
○
variableName: This is the identifier (the name) you choose
for your variable. It should follow Java’s naming conventions (discussed in
1.9.4).
Examples:
// Variable Declarations in Java
int age; // Declares
an integer variable named ‘age’
double
price; // Declares a
double-precision floating-point variable named ‘price’
boolean isActive; // Declares a boolean
variable named ‘isActive‘
char
grade; // Declares a character
variable named ‘grade’
String userName; //
Declares a String variable named ‘userName‘
At this
stage, memory is allocated, but no specific value is assigned (unless it’s an
instance or static variable, which gets a default value, as discussed in
Section 1.8.3).
1.9.3
Initializing Variables
Initializing a variable means assigning it an
initial value. You can do this in a separate step after declaration, or you can
combine declaration and initialization into a single line.
●
Assigning
an Initial Value: variableName = value;
○
The =
operator is the assignment operator. It assigns the value on its right
to the variableName on its left. The value must be
compatible with the dataType of the variable.
Example:
public class VariableExample {
public static void
main(String[] args) {
// Declaration and Initialization
separately
int
score; // Declaration: creates
an integer variable named ‘score’
score =
0; // Initialization: assigns
the value 0 to ‘score’
String greeting; // Declaration: creates a String variable
named ‘greeting’
greeting =
"Hello Java!"; // Initialization: assigns the string "Hello Java!"
to ‘greeting’
// Printing the values
System.out.println("Score: " + score);
System.out.println("Greeting: " + greeting);
}
}
●
Declaration
and Initialization in One Step: dataType variableName
= value;
This is a common and often preferred way to declare
and initialize variables, especially when you know the initial value at the
time of declaration.
Examples:
public class VariableInitializationExample {
public static void
main(String[] args) {
// Declaration and Initialization in a
single step
int
age = 25; // ‘age’ is an
int, initialized to 25
double price =
99.99; // ‘price’ is a double,
initialized to 99.99
boolean
isLoggedOn = true;
// ‘isLoggedOn‘ is a boolean,
initialized to true
char firstInitial = ‘P’;
// ‘firstInitial‘ is a char, initialized to
‘P’
String productName
= "Laptop"; // ‘productName‘ is a String,
initialized to "Laptop"
// Printing the values
System.out.println("Age: " + age);
System.out.println("Price: " + price);
System.out.println("Logged In: " + isLoggedOn);
System.out.println("First Initial: " + firstInitial);
System.out.println("Product Name: " + productName);
}
}
1.9.4
Naming Conventions for Variables
Choosing clear and consistent names for
variables is essential for writing readable and maintainable code. Java has
specific rules and widely adopted conventions for naming variables.
●
Rules for
Valid Variable Names:
○
Must start
with: A letter (a-z,
A-Z), the dollar sign ($), or an underscore (_).
○
Can contain: Letters, digits (0-9), dollar signs ($), or
underscores (_) after the first character.
○
Cannot
contain: Spaces or other
special characters (like !, @, #, %, etc.).
○
Keywords: Cannot be a Java keyword (e.g., public,
class, int, static, void, true, false, null).
○
Case-sensitive: Java is case-sensitive, so age, Age, and AGE
are considered three different variables.
○
No length
limit: While there’s no
strict limit, keep names reasonably concise.
●
Best
Practices:
○
camelCase: The standard convention for variable names in
Java is camelCase. This means the first letter of the
variable name is lowercase, and the first letter of subsequent words is
uppercase.
■
Good: firstName, totalItems, isValidInput, maxSpeed
■
Bad: first_name, totalitems, isvalidinput
○
Meaningful
Names: Choose names
that clearly indicate the variable’s purpose or the data it holds. Avoid
cryptic abbreviations.
■
Good: studentGrade, numberOfStudents, averageScore
■
Bad: sg, num, avg
○
Singular
for Single Values: Use
singular nouns for variables holding a single value (e.g., count, name).
○
Plural for
Collections: Use plural nouns
for variables holding collections of values (e.g., students, scores).
1.9.5 Types
of Variables based on Scope
Variable scope refers to the region
within a program where a variable is accessible and valid. In Java, variables
are broadly categorized into three types based on their scope: local, instance,
and static.
●
Local
Variables |:
○
Definition: Declared inside a method, a constructor, or a
block (any code enclosed within curly braces {}).
○
Scope: Accessible only within the method,
constructor, or block where they are declared. They are created when the method/block
is entered and destroyed when the method/block is exited.
○
Initialization: Unlike instance or static variables, local
variables do not have default values. They must be explicitly
initialized before they can be used; otherwise, the compiler will report an
error.
○
Example:
public class MyClass {
public void myMethod() {
int
localVar = 10; // This is a local variable
System.out.println(localVar); // Accessible here
}
// localVar
ceases to exist outside myMethod
// System.out.println(localVar);
// ❌ COMPILE-TIME ERROR: cannot find symbol
}
●
Instance
Variables |:
○
Definition: Declared inside a class but outside any
method, constructor, or block. They are not declared with the static keyword.
○
Scope: Unique to each object (instance) of the
class. They are created when an object of the class is instantiated (new MyClass())
and destroyed when the object is garbage collected.
○
Initialization: If not explicitly initialized, instance
variables receive default values (e.g., 0 for numeric types, false for boolean, ‘\u0000’ for char, null
for reference types) as discussed in Section 1.8.3.
○
Example:
public class Dog {
// Instance variables
String name;
int
age;
// Constructor
public Dog(String name, int age) {
this.name = name;
// ‘this’ refers to the current object’s instance variable
this.age = age;
}
//
Method to display dog information
public void displayInfo() {
System.out.println("Name: " + name + ", Age: " + age);
}
public static void main(String[] args)
{
// Creating objects of Dog class
Dog myDog = new Dog("Buddy",
5); // ‘name’ and ‘age’ are instance
variables for myDog
Dog anotherDog = new Dog("Lucy",
2); // Separate instance variables for anotherDog
// Displaying information
myDog.displayInfo(); // Output:
Name: Buddy, Age: 5
anotherDog.displayInfo(); // Output: Name:
Lucy, Age: 2
}
}
●
Static
Variables |:
○
Definition: Declared inside a class but outside any
method, constructor, or block, and explicitly declared with the static keyword.
○
Scope: Belong to the class itself, not to any
specific object. There is only one copy of a static variable, regardless of how
many objects of the class are created. They are created when the class is
loaded into memory and exist for the entire duration of the program.
○
Initialization: Like instance variables, if not explicitly
initialized, static variables receive default values.
○
Access: Can be accessed directly using the class name
(e.g., ClassName.staticVariable) without needing to
create an object.
○
Example:
public class Student {
//
Instance variable
String studentName;
//
Static variable (shared by all objects of this class)
static int studentCount
= 0;
//
Constructor
public Student(String name) {
this.studentName = name;
studentCount++; // Increment
static variable whenever a new Student object is created
}
//
Method to display student info
public void displayStudent() {
System.out.println("Student Name: " + studentName
+ ", Total Students: " + studentCount);
}
public static void main(String[] args)
{
// Creating Student objects
Student s1 = new Student("Alice"); //
studentCount becomes 1
Student s2 = new Student("Bob"); // studentCount
becomes 2
Student s3 = new Student("Charlie");
// studentCount becomes 3
// Displaying each student’s info
s1.displayStudent();
// Student Name: Alice, Total Students: 3
s2.displayStudent(); // Student Name: Bob, Total Students: 3
s3.displayStudent(); // Student Name: Charlie, Total
Students: 3
// Accessing static variable via class name
System.out.println("Total Students: " + Student.studentCount);
// Output: 3
}
}
Understanding these different types of
variables and their scopes is fundamental to designing and implementing
well-structured and functional Java programs.
