2. Data Types, Variables, and Operators

In this chapter, we’ll learn how Java stores and manages data using variables, data types, and how we can manipulate that data using operators. This chapter forms the backbone of every Java program.

This section introduces the foundational concepts that Java programming relies on. Variables are special names used to store data so that it can be manipulated. Data types define the kind of data a variable can hold, such as integers or strings. Operators allow us to perform calculations and operations on this data. Understanding these concepts is essential as they are the building blocks for writing any Java program.

Think of variables like storage boxes in a warehouse. Each box (variable) can hold a specific kind of item (data type), like books or toys. Operators are tools that help us to move or manipulate those boxes. Just like if you have different sized boxes for different types of items, in Java, we have different data types for different kinds of information.

Tokens are the smallest individual units in a Java program. There are five types:

1. Keywords – Reserved words with special meaning (e.g., int, class, return)
2. Identifiers – Names for variables, classes, methods, etc.
3. Literals – Constant values directly used in code (e.g., 5, 'A', 3.14)
4. Operators – Symbols that perform operations (+, -, *)
5. Separators – Characters like {}, ;, ,, []

In Java, tokens are the essential building blocks that make up the source code. Keywords are words that have a predefined meaning in programming, identifiers are names you create for your own variables and methods, literals are fixed values you use directly, operators are symbols that perform operations on variables and literals, and separators are characters that help to structure your code, like parentheses and commas.

Imagine writing a recipe. The tokens are like the ingredients and instructions. Keywords are like cooking terms you must use (boil, bake), identifiers are like the names of ingredients (sugar, flour), literals are the specific amounts (1 cup, 2 tablespoons), operators are the actions you're performing (mix, chop), and separators help show the steps clearly (use commas for lists of ingredients).

A variable is a container used to store data. It must be declared with a type before use.

📌 Syntax: dataType variableName = value; ✅ Example: int age = 20; String name = "Aman";

🔒 Rules for Naming Variables: ● Can include letters, digits, underscores, and dollar signs. ● Must begin with a letter or underscore. ● Cannot use Java keywords like class, int, etc. ● Java is case-sensitive (Age and age are different).

Variables in Java need to be declared with a specific data type indicating what kind of data they can hold. For example, 'int' is used for integers, while 'String' is used for text. Following the right syntax is crucial for declaring variables correctly, and there are specific naming rules to avoid conflicts and confusion in code, such as not using reserved keywords.

Think of a variable as a labeled jar in a kitchen. The label (the type, like 'int' or 'String') tells you what kind of ingredients you can store inside. You could put sugar or rice in the jar but if it’s labeled for spices, you wouldn't mix in honey. Just like labels help organize your kitchen, variable names help keep your code organized and understandable.

Java has two categories of data types: 🔹 A. Primitive Data Types Data Type Size Example Description byte 1 byte byte b = 10; Small integer values short 2 bytes short s = 100; Medium range integer values int 4 bytes int i = 200; Default for integers long 8 bytes long l = 10000; Large integer values float 4 bytes float f = 5.5f; Decimal with single precision double 8 bytes double d = 6.89; High precision decimal char 2 bytes char c = 'A'; Single character boolean 1 bit boolean b = true; True or false only 💡 Always add f to float values: float f = 4.3f; 🔹 B. Non-Primitive Data Types ● Strings, Arrays, Classes, Interfaces, etc. ● Created by the programmer, unlike primitive types. Example: String name = "Anjali"; int[] numbers = {1, 2, 3};

Java's data types are split into two main categories: primitive and non-primitive. Primitive data types are basic types like integers and characters with defined sizes, while non-primitive types are more complex, such as strings (a sequence of characters) and arrays (a collection of items). Understanding these types helps you choose the right one for your variable based on the kind of data you need to handle.

Imagine primitive data types as different types of raw materials in a construction site; each type has a specific role—a brick (int), a plank of wood (float), etc. Non-primitive types are like completed structures made from those materials, such as a house (String) or a parking lot (array) that holds multiple cars (values). They rely on the strength and properties of those raw materials but serve a more complex purpose.

👉 Implicit (Widening) Casting: ● Small data type → Big data type ● Happens automatically. int a = 10; double d = a; // Automatically converts int to double

👉 Explicit (Narrowing) Casting: ● Big data type → Small data type ● Must be done manually. double d = 9.7; int i = (int) d; // Converts double to int (loses decimal part)

Type casting is the process of converting a variable from one data type to another. Implicit casting occurs automatically when a smaller type is faced with a larger type, such as an integer being turned into a double. Explicit casting, on the other hand, happens when you manually convert a larger type into a smaller type, which can result in loss of data, for example, converting a double to an int.

Think of implicit casting like pouring a cup of water (small type) into a jug (large type); it fits perfectly and automatically. In contrast, explicit casting is like trying to pour a gallon of water into a teacup (big to small); you have to make a decision on how much you can keep, often leaving some water behind, thus losing information.

Use the final keyword to create constants (values that don’t change). final double PI = 3.14159; Trying to change PI later in the program will give an error.

Constants are values that, once assigned, cannot be changed during the execution of the program. To define a constant in Java, you use the 'final' keyword, which ensures that the value remains fixed. This is useful for values that should not change, such as mathematical constants or configuration settings.

Think of constants like a recipe that specifies a fixed amount of a key ingredient, like sugar. Once you decide that the recipe calls for '1 cup of sugar,' you can't change it halfway through the process; it needs to remain the same every time you make that recipe, just like constants must stay unchanged throughout your program.

Operators are used to perform operations on variables and values. Java provides several categories: 🔹 A. Arithmetic Operators Operator Use Example

•          Addition                     a + b

•          Subtraction                  a - b

•          Multiplication               a * b

/ Division a / b % Modulus a % b (remainder) int a = 10, b = 3; System.out.println(a + b); // 13 System.out.println(a / b); // 3 System.out.println(a % b); // 1 🔹 B. Relational (Comparison) Operators Operator Meaning Example == Equal to a == b != Not equal to a != b

      Greater than      a > b

< Less than a < b

= Greater than or a >= b equal <= Less than or a <= b equal int x = 5, y = 10; System.out.println(x > y); // false 🔹 C. Logical Operators Used to combine multiple conditions. Operator Meaning Example && Logical AND a > 0 && b > 0 ! Logical NOT !(a > 0)

Operators in Java allow you to perform various operations on data. Arithmetic operators perform calculations like addition and multiplication. Relational operators compare values and return true or false based on the comparison. Logical operators allow the combination of multiple conditions to evaluate expressions, making your programming logic more powerful.

Operators can be likened to a toolbox. Each tool (operator) has its own purpose: a hammer for driving nails (arithmetic), a ruler for measuring (relational), and a wrench for adjusting fittings (logical). Just as a carpenter needs the right tools to build furniture, programmers need the correct operators to manipulate data effectively in their programs.

Sometimes multiple operators are used in a single expression. Java follows a precedence rule. For example: int a = 10 + 5 * 2; // Multiplication happens first System.out.println(a); // 20 To control order, use parentheses: int a = (10 + 5) * 2; // 30

Operator precedence determines the order in which operations are performed in complex expressions. In Java, multiplication takes precedence over addition, meaning it is calculated first unless overridden by parentheses, which enforce a specific order. Understanding this is critical for accurate calculations in your code.

Consider cooking a meal with multiple ingredients. If you have to mix flour and sugar before adding eggs, it’s similar to how multiplication must be handled before addition in Java. If you follow the love of mixing everything together without using parentheses, your final dish may not turn out as you expect, just like not respecting operator precedence may lead to incorrect results.

--