✅ Java Basics: Keywords

📌 Concept:

 Keywords are reserved, predefined words in Java.

 There are 51 core Java keywords.

 Each keyword has a specific meaning recognized by the Java

compiler.

⚡ Important Points:

 Cannot be used as identifiers (e.g., variable, method, or class

names).

 Built-in: You can't redefine or change their meaning.

 Used to structure code logic, like declaring data types (int), control
flow (if), class structure (class, public, static).

 Learning them happens naturally through practice — memorization

not required upfront.

✅ Examples:

 int – declares integer variables

 if – conditional branching

 class, void, return, public – used in method and class definitions

✅ Java Basics: Variables & State Data

📌 Concept:

 State data refers to the information our application keeps track of

while it is running (e.g., user’s name, age).

 We store such data in variables.

⚡ Important Points:

 A variable is a named location in memory that holds data.

  The name (e.g., age) refers to a memory location where the value is
stored.

 The value in a variable can be updated at any time — hence the name
variable.

🧠 Assignment:

 Writing age = 42; assigns the value 42 to the variable age.

 The = sign is called the assignment operator.

⚠️Java Requires Type Declaration:

 Unlike some languages (e.g., Python), Java requires declaring the

data type before using a variable.

 Example:

 int age = 42; // ✅ Correct way to declare and assign an integer variable
in Java

age = 43; // ✅ No need to specify type again

 The keyword int specifies the type as integer.

 Once declared, you can reassign the variable without re-declaring its
type.

✅ Java Basics: Static Typing

📌 Concept:

 Java uses static typing, which means the data type is bound to the
variable when it's defined.

 The compiler checks type correctness at compile time.

⚡ Important Points:

 You cannot assign a value of a different type to a statically typed

variable.

 int age = 42;

age = "forty two"; // ❌ Compile-time error

 This helps catch type-related mistakes before the code runs.

  Once a variable is declared with a specific type, it must always store
that type of data.

🔄 Static vs. Dynamic Typing:

Feature Static Typing (Java) Dynamic Typing (Python)

Type Binding Bound to variable Bound to value

Type Check Time Compile-time Run-time

Can Change Type

❌ No ✅ Yes
Later?

Compile error for wrong May cause logic errors at

Example Issue
type run-time

🧠 Key Takeaway:

 Static typing in Java improves reliability and helps catch errors early.

 While dynamic typing offers flexibility, it can lead to unexpected

behavior if not handled carefully.

✅ Java Basics: Statements and Semicolons

📌 Concept:

 Java uses semicolons (;) to indicate the end of a statement.

⚡ Important Points:

 Every executable line in Java must end with a semicolon.

 Omitting a semicolon may cause Java to misinterpret multiple

lines as a single statement, resulting in a compile-time error.

🧠 Example:

int age = 42; // ✅ Correct

int year = 2024 // ❌ Missing semicolon - causes compile error

 Semicolons help the Java compiler parse and separate instructions

correctly.
✅ Java Basics: Primitive vs. Reference Types

📌 Concept:

 In Java, variables can hold primitive values or reference values.

⚡ Primitive Values:

 Represent simple, raw data (e.g., numbers, characters).

 Stored directly in memory.

 Java has 8 primitive types: int, long, short, byte, float, double, char,
boolean.

 Each primitive type has a fixed memory size:

o int = 4 bytes (~ ±2 billion range)

o long = 8 bytes (~ ±9 quintillion range)

⚡ Reference Values:

 A reference points to an object stored elsewhere in memory.

 Used with object types like String, Integer, arrays, and custom
classes.

 Example: Integer age = 42; creates an object, stores it in memory, and

the variable holds a reference like Integer@505.

🧠 Syntax Comparison:

// Primitive type

int age = 42;

// Object type

String text = "Hello there";

Integer number = 42;

🧠 Key Differences:

 Primitive types: Start with lowercase letters and store raw values.

 Object types: Start with uppercase letters and store references.

 Object types can include methods and additional data.

✅ Object Benefits:

 Come with built-in methods (e.g., text.length() for String).

 Allow custom behaviors and fields.

 Enable flexibility and reusability in complex applications.

✅ Java Basics: Typecasting

📌 Concept:

 Typecasting is converting a value from one data type to another.

 Java supports two kinds of typecasting:

o Automatic (Widening)

o Manual (Narrowing)

🔁 Automatic Casting (Widening):

 Happens implicitly, no developer action needed.

 Converts a smaller type to a larger type.

 Example:

int num = 3;

double newNum = num; // Automatically casted to 3.0

 No precision is lost.

✋ Manual Casting (Narrowing):

 Required when converting from a larger type to a smaller type.

 Done using parentheses with the target type.

 Example:

double number = 3.5;

int result = (int) number; // Manual cast: result = 3

 Precision is lost — decimal part is truncated.

 Without manual cast, Java will throw a type mismatch compile-time

error.
⚠️Note:

 Manual casting is also used when converting between object types.

 Always consider whether data might be lost or changed during casting.