Introduction to Java: Java History, Java Features, How Java differs from C, Java and Internet,

Java and World Wide Web, Web Browsers, Hardware and Software Requirements, Java Support
Systems, Java Environment. Overview of Java Language: Introduction, Structure of Java
program, Implementing a Java Program, Java Virtual Machine, Command Line Arguments,
Programming Style. Constants, Variables, and Data Types: Introduction, Tokens, Constants,
Variables, Data Types, Declaration of Variables, Giving Values to Variables, Scope of
Variables, Symbolic Constants, Type Conversions, Getting Values of Variables, Standard
Default Values, Operators and Expressions: Introduction, Arithmetic Operators, Relational
Operators, Logical Operators, Assignment Operators, Increment and Decrement Operators,
Conditional Operators, Bitwise Operators, Special Operators, Arithmetic Expressions,
Evaluation of Expressions, Precedence of Arithmetic Operators, Associativity, Mathematical
Functions. Decision making and branching: if and switch statements, Decision making and
looping: The while, do while and for loops, Jumps in Loops Labeled Loops.

Introduction to Java
Java History

• Definition: Java is a high-level, object-oriented programming language developed by

James Gosling and his team at Sun Microsystems (now owned by Oracle) in the early
1990s. Initially named "Oak" after an oak tree outside Gosling's office, it was later
renamed "Java" in 1995.
• Key Milestones:
o 1991: Project "Oak" initiated for consumer electronics.
o 1995: Renamed "Java" and officially released. Focused on the internet and World
Wide Web.
o 1996: JDK 1.0 released.
o Late 1990s - Early 2000s: Rapid adoption, especially for web applications
(applets, servlets, JSP).
o 2006: Sun makes Java free and open source.
o 2010: Oracle acquires Sun Microsystems, including Java.
o Ongoing: Continuous development and updates (e.g., Java SE, Java EE, Java
ME).

Java Features

• Definition: Key characteristics that define Java's design and functionality.

• Features:
1. Simple: Designed to be easy to learn and use, especially for C/C++ programmers,
by removing complex features like explicit pointers and operator overloading.
2. Object-Oriented: Based on the object-oriented programming (OOP) paradigm.
Everything in Java (except primitive data types) is an object. Concepts include
Encapsulation, Inheritance, Polymorphism, and Abstraction.
 3. Platform Independent (Write Once, Run Anywhere - WORA): Java source
code is compiled into bytecode, which can run on any platform with a Java
Virtual Machine (JVM). This is a core strength.
4. Secure: Features like bytecode verifier, security manager, and absence of pointers
contribute to a secure execution environment, crucial for internet applications.
5. Robust: Strong memory management (garbage collection), exception handling,
and compile-time error checking make Java applications reliable.
6. Multithreaded: Supports concurrent execution of multiple parts of a program,
leading to better performance and responsiveness for interactive applications.
7. High Performance: While interpreted, Java's JIT (Just-In-Time) compiler
converts bytecode into native machine code at runtime, significantly improving
performance.
8. Distributed: Designed for distributed environments, enabling applications to be
built across multiple networks.
9. Dynamic: Can adapt to evolving environments. Classes are loaded on demand.
10. Interpreted: While compiled to bytecode, the bytecode is interpreted by the
JVM.

How Java Differs from C

• Definition: Key distinctions in language design, philosophy, and features between Java
and C.
• Differences:

Feature C Java
Paradigm Procedural Object-Oriented
Platform-dependent (compiled to
Platform Platform-independent (WORA)
native code)
Memory
Manual (malloc(), free()) Automatic (Garbage Collection)
Mgmt.
Pointers Explicitly supported No explicit pointers (references instead)
Multiple
Supported (though complex) Not directly supported (via interfaces)
Inher.
Operator
Supported Not supported
Over.
Goto Stmt. Supported Not supported
Exception Hdl. No built-in Robust try-catch mechanism
Threads No built-in Built-in support for multithreading
Compiles to bytecode (interpreted by
Compilation Compiles to machine code
JVM)
public static void main(String[]
Main Function main() args)
Java and Internet

• Definition: Java's significant role in the development and evolution of internet

applications.
• Role: Java was specifically designed with the internet in mind. Its "Write Once, Run
Anywhere" capability was a perfect fit for web applications where code needed to be
executed on diverse client machines. It powered early interactive web content through
applets and later became foundational for server-side web development.

Java and World Wide Web

• Definition: How Java contributed to and integrated with the World Wide Web.
• Contribution:
o Applets: Small Java programs embedded in web pages, providing dynamic and
interactive content that HTML alone couldn't. (Largely deprecated now due to
security concerns and advancements in client-side technologies like JavaScript).
o Servlets & JSPs: Core technologies for server-side web development, enabling
dynamic web pages, handling user requests, and connecting to databases. These
form the backbone of many enterprise web applications.
o Java EE (Enterprise Edition): A robust platform for building large-scale,
distributed enterprise applications, widely used in e-commerce, banking, and
other industries.

Web Browsers

• Definition: Software applications used to access and view web pages.

• Relation to Java: Early web browsers (like Netscape Navigator and Internet Explorer)
had built-in JVMs to execute Java applets. This allowed Java to deliver rich, interactive
content directly within the browser window. Modern browsers no longer directly support
Java applets.

Hardware and Software Requirements

• Definition: The minimum specifications needed to develop and run Java applications.
• Hardware:
o Processor: Any modern CPU (Intel i3/i5/i7/i9, AMD Ryzen, etc.).
o RAM: Minimum 4GB, 8GB or more recommended for development with IDEs.
o Disk Space: Several GBs for JDK, IDE, and project files.
• Software:
o Operating System: Windows, macOS, Linux (most modern versions).
o Java Development Kit (JDK): Essential for compiling and running Java
programs. Includes JRE, compiler (javac), debugger, etc.
o Integrated Development Environment (IDE) - Optional but Recommended:
Eclipse, IntelliJ IDEA, NetBeans. These provide tools for coding, debugging, and
project management.
 o Text Editor: (Alternative to IDE for simple programs) Notepad++, VS Code,
Sublime Text.

Java Support Systems

• Definition: The ecosystem of tools, libraries, and frameworks that enhance Java
development.
• Examples:
o Build Tools: Maven, Gradle (for managing project dependencies and build
processes).
o Testing Frameworks: JUnit, TestNG (for unit testing).
o Logging Frameworks: Log4j, SLF4J, Logback.
o Web Frameworks: Spring, Jakarta EE (formerly Java EE), Struts, JSF.
o Database Connectivity: JDBC (Java Database Connectivity) API.
o Version Control: Git, SVN.

Java Environment

• Definition: The complete setup required to develop and execute Java applications.
• Components:
1. Java Development Kit (JDK): The core set of tools for Java development.
▪ Java Runtime Environment (JRE): Contains the JVM, core classes, and
supporting files needed to run Java programs.
▪ Java Virtual Machine (JVM): An abstract machine that provides the
runtime environment for Java bytecode.
▪ Compiler (javac): Converts Java source code (.java files) into bytecode
(.class files).
▪ Debugger (jdb): For finding and fixing errors.
▪ Archiver (jar): For packaging Java classes and resources into a single
JAR file.
2. Path and Classpath Configuration: Environment variables that tell the OS
where to find Java executables and class files.
3. Integrated Development Environment (IDE): (As mentioned above) Provides a
rich development experience.

Overview of Java Language

Introduction

• Definition: A brief overview of Java as a programming language, emphasizing its object-

oriented nature and core principles.
• Key Points: Java is a strongly typed, compiled (to bytecode), interpreted (by JVM),
object-oriented language. It emphasizes concepts like classes, objects, inheritance, and
polymorphism to structure programs.
Structure of a Java Program

• Definition: The typical organization and components of a basic Java source file.
• Structure:

Java

// 1. Package Declaration (Optional, but common)

package [Link];

// 2. Import Statements (Optional, but common)

import [Link];
import [Link]; // Implicitly imported

// 3. Class Definition (Mandatory for executable code)

public class MyFirstJavaProgram {

// 4. Main Method (Entry point for standalone applications)

public static void main(String[] args) {
// 5. Statements/Code Block
[Link]("Hello, Java World!"); // Output statement
int number = 10; // Variable declaration and initialization
[Link]("The number is: " + number);
}

// 6. Other methods/fields (Optional)

public void anotherMethod() {
// ...
}
}

• Explanation:
1. Package Declaration: Organizes classes into namespaces. package
packageName;
2. Import Statements: Allows using classes from other packages without fully
qualifying their names. import [Link]; or import
packageName.*;
3. Class Definition: All Java code resides within classes. public class ClassName {
... }
4. Main Method: The starting point of execution for any standalone Java
application. public static void main(String[] args) { ... }
▪ public: Access modifier, visible everywhere.
▪ static: Allows the method to be called without creating an object of the
class.
▪ void: Indicates the method does not return any value.
▪ main: The standard name for the entry point method.
 ▪ String[] args: An array of String objects to receive command-line
arguments.
5. Statements: Individual instructions that perform actions. Terminated by a
semicolon ;.
6. Comments: Used for documentation, ignored by the compiler.
▪ Single-line: // This is a single-line comment
▪ Multi-line: /* This is a multi-line comment */
▪ Javadoc: /** This is a Javadoc comment */

Implementing a Java Program

• Definition: The steps involved in writing, compiling, and running a Java program.
• Steps:
1. Write Source Code: Use a text editor or IDE to write Java code and save it with
a .java extension (e.g., [Link]). The class name should match the
filename.

Example ([Link]):

Java

public class HelloWorld {

public static void main(String[] args) {
[Link]("Hello from Java!");
}
}

2. Compile: Open a command prompt/terminal, navigate to the directory where you

saved the file, and use the javac command.

Bash

javac [Link]

▪ Output: If successful, this creates a [Link] file (bytecode) in

the same directory. If there are errors, javac will report them.
3. Run: Use the java command followed by the class name (without the .class
extension).

Bash

java HelloWorld

▪ Output:
▪ Hello from Java!
Java Virtual Machine (JVM)

• Definition: An abstract machine that provides the runtime environment for Java
bytecode. It's the core component that enables Java's "Write Once, Run Anywhere"
capability.
• Role:
o Interprets Bytecode: Reads and executes the .class files (bytecode).
o Platform Independence: Translates generic bytecode into native machine code
specific to the underlying operating system and hardware.
o Memory Management: Manages memory allocation and deallocation (garbage
collection).
o Security: Enforces security policies.
o Just-In-Time (JIT) Compiler: Optimizes performance by compiling frequently
executed bytecode sections into native machine code during runtime.
• Analogy: Think of the JVM as a universal interpreter that understands Java's
intermediate language (bytecode) and can speak the native language of any computer it's
installed on.

Command Line Arguments

• Definition: Values passed to a Java program when it's executed from the command line.
These values are received by the main method's String[] args parameter.
• Usage:

Example ([Link]):

Java

public class CmdArgsDemo {

public static void main(String[] args) {
[Link]("Number of arguments: " + [Link]);
if ([Link] > 0) {
[Link]("Arguments received:");
for (int i = 0; i < [Link]; i++) {
[Link]("Arg " + (i + 1) + ": " + args[i]);
}
} else {
[Link]("No arguments provided.");
}
}
}

• Compilation & Execution:

Bash
 javac [Link]
java CmdArgsDemo Hello World 123

• Output:
• Number of arguments: 3
• Arguments received:
• Arg 1: Hello
• Arg 2: World
• Arg 3: 123

Programming Style

• Definition: A set of conventions and guidelines for writing source code that enhances
readability, maintainability, and consistency. While not enforced by the compiler, good
style is crucial for collaborative development and long-term project health.
• Key Principles:
o Meaningful Names: Use descriptive names for variables, methods, and classes
(e.g., numberOfStudents instead of num).
o Indentation: Use consistent indentation (e.g., 4 spaces or 1 tab) to show code
block structure.
o White Space: Use spaces around operators, after commas, and to separate logical
blocks of code.
o Comments: Use comments to explain complex logic, design decisions, or non-
obvious parts of the code.
o Curly Brace Placement: Consistent placement (e.g., K&R style or Allman style).
o Line Length: Keep lines relatively short (e.g., 80-120 characters).
o Class/Method Size: Keep classes and methods focused and reasonably sized.
o Avoid Magic Numbers: Use named constants instead of hardcoded literal values.
o Follow Naming Conventions (CamelCase, PascalCase, SNAKE_CASE):
▪ Classes/Interfaces: PascalCase (e.g., MyClassName)
▪ Methods/Variables: camelCase (e.g., myMethodName,
myVariableName)
▪ Constants: SCREAMING_SNAKE_CASE (e.g., MAX_VALUE)
▪ Packages: lowercase (e.g., [Link])
• Benefits:
o Improved readability and understanding.
o Easier debugging and maintenance.
o Better collaboration among developers.
o Reduced errors.

Constants, Variables, and Data Types

Introduction

• Definition: Fundamental building blocks of any program, representing pieces of data that
a program manipulates.
 • Key Concepts:
o Constants: Fixed values that do not change during program execution.
o Variables: Named memory locations that hold values that can change during
program execution.
o Data Types: Define the type of data a variable can hold and the operations that
can be performed on it.

Tokens

• Definition: The smallest individual units of a program that are meaningful to the
compiler.
• Types of Tokens in Java:
1. Keywords: Reserved words with predefined meanings (e.g., public, class, int, if,
else).
2. Identifiers: Names given to classes, methods, variables, etc., chosen by the
programmer.
3. Literals: Fixed values (constants) written directly in the code (e.g., 100, 3.14, 'A',
"Hello").
4. Operators: Symbols that perform operations on operands (e.g., +, -, *, /, =, >).
5. Separators (Delimiters): Symbols used to organize code (e.g., { }, ( ), [ ], ;, ,, .).

Constants

• Definition: Fixed values that do not change during the execution of a program. They are
also known as literals.
• Types of Constants (Literals):
1. Integer Literals: Whole numbers.
▪ Decimal: 10, 123
▪ Octal (prefix 0): 010 (decimal 8)
▪ Hexadecimal (prefix 0x or 0X): 0xFF (decimal 255)
▪ Binary (prefix 0b or 0B): 0b101 (decimal 5)
▪ Suffix L or l for long: 123L
2. Floating-Point Literals: Numbers with decimal points.
▪ Suffix F or f for float: 3.14f
▪ Suffix D or d for double (default): 3.14 or 3.14d
3. Character Literals: Single characters enclosed in single quotes.
▪ 'A', 'x', '5', '$'
▪ Escape sequences: '\n' (newline), '\t' (tab), '\\' (backslash), '\'' (single
quote), '\"' (double quote)
4. String Literals: Sequences of characters enclosed in double quotes.
▪ "Hello World", "Java Programming"
5. Boolean Literals: Represent truth values.
▪ true, false
6. Null Literal: Represents the absence of an object reference.
▪ null
Variables

• Definition: Named memory locations used to store data. The value stored in a variable
can change during program execution.
• Declaration: Specifying the data type and name of a variable.
• Initialization: Assigning an initial value to a variable.

Data Types

• Definition: Classify the type of data a variable can hold. Java is a strongly typed
language, meaning every variable must have a declared data type.
• Categories:
1. Primitive Data Types (Built-in): Represent basic values directly.
▪ Boolean:
▪ boolean: true or false (1 bit, but JVM often uses 1 byte)
▪ Numeric:
▪ Integer Types: Store whole numbers.
▪ byte: 1 byte (-128 to 127)
▪ short: 2 bytes (-32,768 to 32,767)
▪ int: 4 bytes (-2,147,483,648 to 2,147,483,647) - Default for
integers
▪ long: 8 bytes (-9,223,372,036,854,775,808 to
9,223,372,036,854,775,807)
▪ Floating-Point Types: Store numbers with decimal components.
▪ float: 4 bytes (single-precision)
▪ double: 8 bytes (double-precision) - Default for floating-
points
▪ Character Type:
▪ char: 2 bytes (stores Unicode characters, \u0000 to \uffff)
2. Non-Primitive (Reference) Data Types: Refer to objects. They don't store the
actual value but a memory address (reference) where the object is stored.
▪ String: Represents a sequence of characters.
▪ Arrays: Ordered collections of elements of the same type.
▪ Classes: User-defined blueprints for objects.
▪ Interfaces: Blueprints of a class.

Declaration of Variables

• Definition: The process of creating a variable by specifying its data type and name.
• Syntax: dataType variableName;
• Examples:

Java

int age;
double price;
 char grade;
boolean isActive;
String name;

Giving Values to Variables (Initialization & Assignment)

• Definition: Storing a value in a variable.

• Initialization (at declaration): dataType variableName = value;

Java

int age = 30;

double price = 99.99;
char grade = 'A';
boolean isActive = true;
String name = "Alice";

• Assignment (after declaration): variableName = value;

Java

int score; // Declaration

score = 100; // Assignment
score = 150; // Re-assignment

Scope of Variables

• Definition: The region of a program where a variable is accessible and can be used.
Variables are accessible only within the block ({ }) where they are declared.
• Types of Scope:
1. Local Variables: Declared inside a method, constructor, or block. They are
created when the block is entered and destroyed when the block is exited. Must be
explicitly initialized before use.

Java

public void myMethod() {

int x = 10; // Local variable to myMethod
if (x > 5) {
String message = "Hello"; // Local variable to the if block
[Link](message);
}
// [Link](message); // ERROR: message is out of scope here
[Link](x); // x is still in scope
}
 2. Instance Variables (Non-static fields): Declared inside a class but outside any
method or constructor. They belong to an object (instance) of the class. Each
object has its own copy. Automatically get default values if not initialized.

Java

public class MyClass {

int instanceVar; // Instance variable
String instanceName;
}

3. Class Variables (Static fields): Declared inside a class, outside any

method/constructor, with the static keyword. They belong to the class itself, not to
any specific object. There's only one copy shared by all objects of the class.
Automatically get default values.

Java

public class MyClass {

static int classVar; // Class variable
static final double PI = 3.14159; // Static constant
}

4. Method Parameters: Variables passed into a method. Their scope is limited to

that method.

Symbolic Constants

• Definition: Constants declared using the final keyword. Their value, once assigned,
cannot be changed. Often used with static to create class-level constants.
• Syntax: final dataType CONSTANT_NAME = value; (By convention, static final
constants are in SCREAMING_SNAKE_CASE).
• Example:

Java

public class Circle {

public static final double PI = 3.14159; // Symbolic constant (class-level)
public final int MAX_RADIUS = 100; // Symbolic constant (instance-level)

public void calculateArea(double radius) {

// PI = 3.0; // ERROR: Cannot assign a value to a final variable
double area = PI * radius * radius;
[Link]("Area: " + area);
}
}
Type Conversions (Type Casting)

• Definition: The process of converting a value from one data type to another.
• Types:
1. Implicit Type Conversion (Widening Conversion / Automatic):
▪ Happens automatically when converting a smaller data type to a larger
one, where no data loss is possible.
▪ Order: byte -> short -> int -> long -> float -> double
▪ Example:

Java

int i = 100;
long l = i; // int to long (implicit)
float f = l; // long to float (implicit, can lose precision for very large
longs)
[Link]("i: " + i + ", l: " + l + ", f: " + f);

Output: i: 100, l: 100, f: 100.0

2. Explicit Type Conversion (Narrowing Conversion / Manual):

▪ Requires a cast operator (dataType) because there's a possibility of data
loss (e.g., converting a larger type to a smaller one).
▪ Syntax: targetDataType variable = (targetDataType) sourceVariable;
▪ Example:

Java

double d = 100.99;
int i = (int) d; // double to int (explicit, data loss: .99 is truncated)
byte b = (byte) i; // int to byte (explicit, data loss if i > 127 or i < -128)
[Link]("d: " + d + ", i: " + i + ", b: " + b);

int x = 200;
byte y = (byte) x; // 200 is out of byte range (-128 to 127), will wrap
around
[Link]("x: " + x + ", y: " + y); // y will be -56

Output:

d: 100.99, i: 100, b: 100

x: 200, y: -56

Getting Values of Variables (Input)

• Definition: How to read input from various sources, typically the console (keyboard).
• Using Scanner Class: The most common way to read input from the console.
• Steps:
1. Import the Scanner class: import [Link];
2. Create a Scanner object: Scanner scanner = new Scanner([Link]);
3. Use Scanner methods to read different data types:
▪ nextInt(): Reads an integer.
▪ nextDouble(): Reads a double.
▪ nextBoolean(): Reads a boolean.
▪ next(): Reads a single word (token) as a String.
▪ nextLine(): Reads an entire line as a String.
• Example:

Java

import [Link];

public class UserInput {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

[Link]("Enter your name: ");

String name = [Link](); // Reads the whole line

[Link]("Enter your age: ");

int age = [Link](); // Reads an integer

[Link]("Enter your height (in meters): ");

double height = [Link](); // Reads a double

[Link]("\n--- Your Information ---");

[Link]("Name: " + name);
[Link]("Age: " + age + " years old");
[Link]("Height: " + height + " meters");

[Link](); // Close the scanner to release resources

}
}

• Output (User Input in bold):

• Enter your name: **John Doe**
• Enter your age: **25**
• Enter your height (in meters): **1.75**
•
• --- Your Information ---
• Name: John Doe
• Age: 25 years old
 • Height: 1.75 meters

Standard Default Values

• Definition: Values that instance variables and static variables (class variables)
automatically get if they are not explicitly initialized. Local variables do not get default
values and must be initialized before use.
• Defaults:
o Numeric Types (byte, short, int, long, float, double): 0 or 0.0
o char: '\u0000' (null character)
o boolean: false
o Reference Types (String, Arrays, Objects): null
• Example:

Java

public class DefaultValues {

int intVar; // Instance variable, default 0
double doubleVar; // Instance variable, default 0.0
boolean booleanVar; // Instance variable, default false
String stringVar; // Instance variable, default null
char charVar; // Instance variable, default '\u0000'

static int staticIntVar; // Static variable, default 0

public static void main(String[] args) {

DefaultValues obj = new DefaultValues();
[Link]("Instance intVar: " + [Link]);
[Link]("Instance doubleVar: " + [Link]);
[Link]("Instance booleanVar: " + [Link]);
[Link]("Instance stringVar: " + [Link]);
[Link]("Instance charVar (casted to int): " + (int)[Link]); // Prints 0
[Link]("Static intVar: " + [Link]);

// int localVar; // Local variable - if not initialized, will cause compile error if used
// [Link](localVar); // COMPILE ERROR: variable might not have been
initialized
int localVar = 10; // OK
[Link]("Local var: " + localVar);
}
}

• Output:
• Instance intVar: 0
• Instance doubleVar: 0.0
• Instance booleanVar: false
 • Instance stringVar: null
• Instance charVar (casted to int): 0
• Static intVar: 0
• Local var: 10

Operators and Expressions

Introduction

• Definition:
o Operators: Symbols that perform specific operations on one or more operands.
o Operands: The values or variables on which operators act.
o Expressions: A combination of operators, operands, literals, and method calls
that evaluates to a single value.

Arithmetic Operators

• Definition: Used to perform basic mathematical calculations.

• Operators:
o + (Addition)
o - (Subtraction)
o * (Multiplication)
o / (Division)
o % (Modulus - remainder after division)
• Example:

Java

int a = 10, b = 3;
[Link]("a + b = " + (a + b)); // 13
[Link]("a - b = " + (a - b)); // 7
[Link]("a * b = " + (a * b)); // 30
[Link]("a / b = " + (a / b)); // 3 (integer division)
[Link]("a % b = " + (a % b)); // 1
double x = 10.0, y = 3.0;
[Link]("x / y = " + (x / y)); // 3.333...

• Output:
• a + b = 13
• a-b=7
• a * b = 30
• a/b=3
• a%b=1
• x / y = 3.3333333333333335
Relational Operators

• Definition: Used to compare two operands and determine the relationship between them.
They always return a boolean (true/false) value.
• Operators:
o == (Equal to)
o != (Not equal to)
o > (Greater than)
o < (Less than)
o >= (Greater than or equal to)
o <= (Less than or equal to)
• Example:

Java

int p = 5, q = 10;
[Link]("p == q: " + (p == q)); // false
[Link]("p != q: " + (p != q)); // true
[Link]("p > q: " + (p > q)); // false
[Link]("p < q: " + (p < q)); // true
[Link]("p >= 5: " + (p >= 5)); // true
[Link]("q <= 10: " + (q <= 10)); // true

• Output:
• p == q: false
• p != q: true
• p > q: false
• p < q: true
• p >= 5: true
• q <= 10: true

Logical Operators

• Definition: Used to combine or manipulate boolean expressions.

• Operators:
o && (Logical AND - short-circuiting)
o || (Logical OR - short-circuiting)
o ! (Logical NOT)
o & (Bitwise AND / Logical AND - non-short-circuiting)
o | (Bitwise OR / Logical OR - non-short-circuiting)
• Short-circuiting:
o &&: If the left operand is false, the right operand is not evaluated.
o ||: If the left operand is true, the right operand is not evaluated.
• Example:

Java
 boolean isSunny = true;
boolean isWarm = false;

[Link]("isSunny && isWarm: " + (isSunny && isWarm)); // false

[Link]("isSunny || isWarm: " + (isSunny || isWarm)); // true
[Link]("!isSunny: " + (!isSunny)); // false

int num = 10;

// Example of short-circuiting
// If (num > 5) is false, (10 / (num - 10) == 0) will not be evaluated, preventing division
by zero.
if (num > 5 && num < 15) {
[Link]("Num is between 5 and 15 (exclusive)."); // True
}
if (num < 0 || num > 5) {
[Link]("Num is negative or greater than 5."); // True (second part
evaluated)
}

• Output:
• isSunny && isWarm: false
• isSunny || isWarm: true
• !isSunny: false
• Num is between 5 and 15 (exclusive).
• Num is negative or greater than 5.

Assignment Operators

• Definition: Used to assign a value to a variable.

• Operators:
o = (Simple assignment)
o += (Add and assign: a += b is a = a + b)
o -= (Subtract and assign: a -= b is a = a - b)
o *= (Multiply and assign: a *= b is a = a * b)
o /= (Divide and assign: a /= b is a = a / b)
o %= (Modulus and assign: a %= b is a = a % b)
o And similar for bitwise operators: &=, |=, ^=, <<=, >>=, >>>=
• Example:

Java

int x = 10;
x += 5; // x is now 15 (x = 10 + 5)
[Link]("x after += 5: " + x);

x -= 3; // x is now 12 (x = 15 - 3)
 [Link]("x after -= 3: " + x);

x *= 2; // x is now 24 (x = 12 * 2)
[Link]("x after *= 2: " + x);

x /= 4; // x is now 6 (x = 24 / 4)
[Link]("x after /= 4: " + x);

x %= 5; // x is now 1 (x = 6 % 5)
[Link]("x after %= 5: " + x);

• Output:
• x after += 5: 15
• x after -= 3: 12
• x after *= 2: 24
• x after /= 4: 6
• x after %= 5: 1

Increment and Decrement Operators

• Definition: Unary operators used to increase or decrease the value of a variable by 1.

• Operators:
o ++ (Increment)
o -- (Decrement)
• Forms:
o Prefix (++variable, --variable): Increments/decrements the value before the
variable is used in the expression.
o Postfix (variable++, variable--): Increments/decrements the value after the
variable is used in the expression.
• Example:

Java

int a = 5;
int b = a++; // b = 5, a = 6
[Link]("a: " + a + ", b: " + b);

int x = 5;
int y = ++x; // y = 6, x = 6
[Link]("x: " + x + ", y: " + y);

int c = 10;
int d = c--; // d = 10, c = 9
[Link]("c: " + c + ", d: " + d);
 int m = 10;
int n = --m; // n = 9, m = 9
[Link]("m: " + m + ", n: " + n);

• Output:
• a: 6, b: 5
• x: 6, y: 6
• c: 9, d: 10
• m: 9, n: 9

Conditional Operator (Ternary Operator)

• Definition: A shorthand for a simple if-else statement. It's the only ternary operator
(takes three operands).
• Syntax: condition ? expressionIfTrue : expressionIfFalse;
• Example:

Java

int score = 75;

String result = (score >= 60) ? "Pass" : "Fail";
[Link]("Result: " + result); // Output: Pass

int num1 = 20, num2 = 15;

int max = (num1 > num2) ? num1 : num2;
[Link]("Maximum: " + max); // Output: Maximum: 20

• Output:
• Result: Pass
• Maximum: 20

Bitwise Operators

• Definition: Operate on individual bits of integer data types (byte, short, int, long). They
treat operands as sequences of binary bits.
• Operators:
o & (Bitwise AND)
o | (Bitwise OR)
o ^ (Bitwise XOR - exclusive OR)
o ~ (Bitwise NOT / One's Complement - unary)
o << (Left Shift)
o >> (Signed Right Shift)
o >>> (Unsigned Right Shift)
• Example:
 Java

int a = 5; // Binary: 0101

int b = 3; // Binary: 0011

[Link]("a & b: " + (a & b)); // 0001 (1)

[Link]("a | b: " + (a | b)); // 0111 (7)
[Link]("a ^ b: " + (a ^ b)); // 0110 (6)
[Link]("~a: " + (~a)); // -6 (one's complement of 5 is -6 in 2's
complement)

int num = 8; // Binary: 0000 1000

[Link]("num << 1: " + (num << 1)); // 0001 0000 (16 - multiply by 2^n)
[Link]("num >> 1: " + (num >> 1)); // 0000 0100 (4 - divide by 2^n)

int negNum = -8; // Binary (2's complement for -8): 1111 1000
[Link]("negNum >> 1: " + (negNum >> 1)); // 1111 1100 (-4) - preserves
sign bit
[Link]("negNum >>> 1: " + (negNum >>> 1)); // 0111 1100 (2147483644) -
fills with 0s

• Output:
• a & b: 1
• a | b: 7
• a ^ b: 6
• ~a: -6
• num << 1: 16
• num >> 1: 4
• negNum >> 1: -4
• negNum >>> 1: 2147483644

Special Operators

• Definition: Operators that don't fit into the other categories, performing specific roles.
• Operators:
o . (Dot operator): Used to access members (fields and methods) of a class or
object.
▪ [Link](): System class, out object, println() method.
▪ [Link]()
o new operator: Used to create new objects (allocate memory for them).
▪ MyClass obj = new MyClass();
o instanceof operator: Used to check if an object is an instance of a particular class
or an interface. Returns boolean.
▪ if (obj instanceof String)
o [] (Square brackets): Used for array declaration, creation, and accessing array
elements.
 ▪ int[] numbers = new int[5];
▪ numbers[0] = 10;
o (type) (Cast operator): Already covered in Type Conversions. Used to explicitly
convert one data type to another.
• Example:

Java

String s = "Hello";
[Link]("Length: " + [Link]()); // Dot operator to access method

Scanner scanner = new Scanner([Link]); // new operator to create object

Object myObject = "Java";

if (myObject instanceof String) { // instanceof operator
[Link]("myObject is an instance of String.");
}

int[] nums = new int[3]; // Array creation

nums[0] = 1; // Accessing array element
[Link]("First element: " + nums[0]);

• Output:
• Length: 5
• myObject is an instance of String.
• First element: 1

Arithmetic Expressions

• Definition: Combinations of operands, arithmetic operators, and parentheses that

evaluate to a numeric value.
• Examples:
o a+b*c
o (x + y) / 2
o area * (1 + rate)

Evaluation of Expressions

• Definition: The process by which the Java compiler determines the value of an
expression. This follows strict rules of operator precedence and associativity.

Precedence of Arithmetic Operators

• Definition: The order in which operators are evaluated in an expression. Higher

precedence operators are evaluated before lower precedence operators.
• Order (Highest to Lowest):
 1. () (Parentheses - control explicit order)
2. ++, -- (Postfix increment/decrement)
3. ++, --, + (Unary plus), - (Unary minus), ~, ! (Prefix increment/decrement, unary
operators)
4. *, /, % (Multiplicative)
5. +, - (Additive)
o (Followed by shift, relational, equality, bitwise, logical, conditional, assignment
operators)
• Example:

Java

int result = 5 + 2 * 3; // Multiplication (2*3=6) first, then addition (5+6=11)

[Link]("5 + 2 * 3 = " + result); // Output: 11

int anotherResult = (5 + 2) * 3; // Parentheses first (5+2=7), then multiplication (7*3=21)

[Link]("(5 + 2) * 3 = " + anotherResult); // Output: 21

• Output:
• 5 + 2 * 3 = 11
• (5 + 2) * 3 = 21

Associativity

• Definition: The direction in which operators of the same precedence are evaluated.
• Rules:
o Most binary operators (arithmetic, relational, logical) are left-to-right
associative.
▪ a - b + c is evaluated as (a - b) + c
o Assignment operators, unary operators, and the conditional operator are right-to-
left associative.
▪ a = b = c is evaluated as a = (b = c)
▪ !true && false is evaluated as (!true) && false
• Example:

Java

int x = 10, y = 5, z = 2;
int res1 = x - y + z; // (10 - 5) + 2 = 5 + 2 = 7
[Link]("x - y + z = " + res1); // Output: 7

int res2 = x = y = 20; // x = (y = 20) -> y becomes 20, then x becomes 20

[Link]("x = y = 20; x: " + x + ", y: " + y + ", res2: " + res2); // Output: x: 20,
y: 20, res2: 20

• Output:
 • x-y+z=7
• x = y = 20; x: 20, y: 20, res2: 20

Mathematical Functions (from [Link] class)

• Definition: Java provides a built-in Math class in the [Link] package (no import
needed) that offers common mathematical functions and constants.
• Common Methods:
o [Link](num): Absolute value.
o [Link](num): Square root.
o [Link](base, exponent): Power.
o [Link](double/float): Rounds to the nearest long/int.
o [Link](double): Rounds up to the nearest integer.
o [Link](double): Rounds down to the nearest integer.
o [Link](a, b): Returns the smaller of two numbers.
o [Link](a, b): Returns the larger of two numbers.
o [Link]: Value of Pi.
o Math.E: Value of e (base of natural logarithm).
• Example:

Java

double num = 25.0;

[Link]("Absolute of -10: " + [Link](-10)); // 10
[Link]("Square root of " + num + ": " + [Link](num)); // 5.0
[Link]("2 to the power of 3: " + [Link](2, 3)); // 8.0
[Link]("Round 4.6: " + [Link](4.6)); // 5
[Link]("Round 4.3: " + [Link](4.3)); // 4
[Link]("Ceil 4.1: " + [Link](4.1)); // 5.0
[Link]("Floor 4.9: " + [Link](4.9)); // 4.0
[Link]("Min(10, 20): " + [Link](10, 20)); // 10
[Link]("Max(10, 20): " + [Link](10, 20)); // 20
[Link]("Value of PI: " + [Link]);

• Output:
• Absolute of -10: 10
• Square root of 25.0: 5.0
• 2 to the power of 3: 8.0
• Round 4.6: 5
• Round 4.3: 4
• Ceil 4.1: 5.0
• Floor 4.9: 4.0
• Min(10, 20): 10
• Max(10, 20): 20
• Value of PI: 3.141592653589793
Decision Making and Branching

if and switch statements

• Definition: Control flow statements that allow a program to execute different blocks of
code based on certain conditions.

if statement

• Definition: Executes a block of code if a specified condition is true.

• Forms:
1. Simple if:

Java

if (condition) {
// Code to execute if condition is true
}

2. if-else: Executes one block if the condition is true, and another if it's false.

Java

if (condition) {
// Code if true
} else {
// Code if false
}

3. if-else if-else (Ladder): Checks multiple conditions sequentially.

Java

if (condition1) {
// Code if condition1 is true
} else if (condition2) {
// Code if condition2 is true
} else if (condition3) {
// Code if condition3 is true
} else {
// Code if none of the above conditions are true
}

4. Nested if: An if statement inside another if or else block.

• Example:
 Java

int score = 85;

if (score >= 90) {
[Link]("Grade: A");
} else if (score >= 80) {
[Link]("Grade: B"); // This will be executed
} else if (score >= 70) {
[Link]("Grade: C");
} else {
[Link]("Grade: D or F");
}

boolean isLoggedIn = true;

boolean isAdmin = false;
if (isLoggedIn) {
if (isAdmin) {
[Link]("Welcome, Administrator!");
} else {
[Link]("Welcome, User!"); // This will be executed
}
} else {
[Link]("Please log in.");
}

• Output:
• Grade: B
• Welcome, User!

switch statement

• Definition: Allows a variable to be tested for equality against a list of values (cases). It
provides a more elegant way to handle multiple if-else if conditions when comparing a
single value.
• Syntax:

Java

switch (expression) {
case value1:
// Code block 1
break; // Optional, to exit the switch
case value2:
// Code block 2
break;
// ... more cases
 default: // Optional
// Code block if no case matches
break;
}

• Key Points:
o expression can be byte, short, int, char, String, enum, or wrapper classes (Byte,
Short, Integer, Character).
o value must be a literal or a final constant.
o break statement is crucial to prevent "fall-through" (execution of subsequent case
blocks).
o default case is optional and executes if no case matches.
• Example:

Java

int dayOfWeek = 3; // 1=Monday, 2=Tuesday, etc.

String dayName;

switch (dayOfWeek) {
case 1:
dayName = "Monday";
break;
case 2:
dayName = "Tuesday";
break;
case 3:
dayName = "Wednesday"; // This will be executed
break;
case 4:
dayName = "Thursday";
break;
case 5:
dayName = "Friday";
break;
case 6:
case 7: // Multiple cases for the same block
dayName = "Weekend";
break;
default:
dayName = "Invalid Day";
break;
}
[Link]("Day " + dayOfWeek + " is: " + dayName); // Output: Day 3 is:
Wednesday
 char grade = 'B';
switch (grade) {
case 'A':
[Link]("Excellent!");
break;
case 'B':
[Link]("Good!"); // This will be executed
break;
case 'C':
[Link]("Fair!");
break;
default:
[Link]("Needs improvement.");
}

• Output:
• Day 3 is: Wednesday
• Good!

Decision Making and Looping

The while, do-while, and for loops

• Definition: Control flow statements that allow a block of code to be executed repeatedly
as long as a certain condition is met.

The while loop

• Definition: Repeats a block of code as long as a condition is true. The condition is

checked before each iteration. If the condition is initially false, the loop body will not
execute even once.
• Syntax:

Java

while (condition) {
// Code to be executed repeatedly
// Update condition variable (important to avoid infinite loop)
}

• Example:

Java

int count = 1;
 [Link]("Counting up using while loop:");
while (count <= 5) {
[Link]("Count: " + count);
count++; // Increment count, otherwise it's an infinite loop
}

• Output:
• Counting up using while loop:
• Count: 1
• Count: 2
• Count: 3
• Count: 4
• Count: 5

The do-while loop

• Definition: Similar to the while loop, but the loop body is executed at least once before
the condition is checked. The condition is checked after each iteration.
• Syntax:

Java

do {
// Code to be executed repeatedly
// Update condition variable
} while (condition);

• Example:

Java

int i = 1;
[Link]("\nCounting up using do-while loop:");
do {
[Link]("i: " + i);
i++;
} while (i <= 5);

int j = 10;
[Link]("\nDo-while with false initial condition:");
do {
[Link]("This will print once: " + j);
j++;
} while (j < 5); // Condition is false, but loop runs once

• Output:
 • Counting up using do-while loop:
• i: 1
• i: 2
• i: 3
• i: 4
• i: 5
•
• Do-while with false initial condition:
• This will print once: 10

The for loop

• Definition: Provides a concise way to write loops that need to be executed a specific
number of times. It's ideal when you know the number of iterations beforehand.
• Syntax:

Java

for (initialization; condition; update) {

// Code to be executed repeatedly
}

oInitialization: Executed once at the beginning of the loop (e.g., int i = 0;).
oCondition: Evaluated before each iteration. If true, the loop continues; if false, it
terminates.
o Update: Executed after each iteration (e.g., i++).
• Example:

Java

[Link]("\nCounting up using for loop:");

for (int k = 1; k <= 5; k++) {
[Link]("k: " + k);
}

[Link]("\nCounting down using for loop:");

for (int l = 5; l >= 1; l--) {
[Link]("l: " + l);
}

// Nested for loop (e.g., for printing a pattern)

[Link]("\nNested for loop (star pattern):");
for (int row = 1; row <= 3; row++) {
for (int col = 1; col <= row; col++) {
[Link]("* ");
}
 [Link](); // New line after each row
}

• Output:
• Counting up using for loop:
• k: 1
• k: 2
• k: 3
• k: 4
• k: 5
•
• Counting down using for loop:
• l: 5
• l: 4
• l: 3
• l: 2
• l: 1
•
• Nested for loop (star pattern):
• *
• **
• ***

Jumps in Loops (break and continue)

• Definition: Statements that alter the normal flow of control within loops.

1. break statement:
o Definition: Immediately terminates the innermost loop (or switch statement) and
transfers control to the statement immediately following the loop/switch.
o Example:

Java

[Link]("\nBreak statement example:");

for (int i = 1; i <= 10; i++) {
if (i == 5) {
break; // Exit the loop when i is 5
}
[Link]("i: " + i);
}
[Link]("Loop ended.");

o Output:
o Break statement example:
o i: 1
 o i: 2
o i: 3
o i: 4
o Loop ended.
2. continue statement:
o Definition: Skips the rest of the current iteration of the innermost loop and
proceeds to the next iteration (evaluates the loop's condition and update
expression).
o Example:

Java

[Link]("\nContinue statement example:");

for (int i = 1; i <= 5; i++) {
if (i == 3) {
continue; // Skip printing when i is 3
}
[Link]("i: " + i);
}

o Output:
o Continue statement example:
o i: 1
o i: 2
o i: 4
o i: 5

Labeled Loops

• Definition: A feature in Java (and some other languages) that allows you to break or
continue from an outer loop when you have nested loops. You assign a label (an
identifier followed by a colon) to the loop you want to target.
• Syntax:

Java

labelName:
loopStatement {
// ...
if (condition) {
break labelName; // Breaks out of the labeled loop
// or
continue labelName; // Continues to the next iteration of the labeled loop
}
}
• Example (break with label):

Java

[Link]("\nLabeled break example:");

outerLoop: // Label for the outer loop
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
if (i * j == 4) {
[Link]("Breaking from outerLoop at i=" + i + ", j=" + j);
break outerLoop; // Exits both loops
}
[Link]("i=" + i + ", j=" + j);
}
}
[Link]("After labeled break.");

Output:

• Labeled break example:

• i=1, j=1
• i=1, j=2
• i=1, j=3
• i=2, j=1
• i=2, j=2

Breaking from outerLoop at i=2, j=2

After labeled break.

• Example (continue with label):

Java

[Link]("\nLabeled continue example:");

outerLoop:
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
if (i == 2) {
[Link]("Continuing outerLoop at i=" + i + ", j=" + j);
continue outerLoop; // Skips to the next iteration of the outer loop (i=3)
}
[Link]("i=" + i + ", j=" + j);
}
}
[Link]("After labeled continue.");
• Output:
• Labeled continue example:
• i=1, j=1
• i=1, j=2
• i=1, j=3

Continuing outerLoop at i=2, j=1

• i=3, j=1
• i=3, j=2
• i=3, j=3
After labeled continue.