1.1.

Core Java: Introduction

The term "Core Java" describes the fundamental and necessary elements of the Java programming
language. Java is an object-oriented, platform-neutral, and flexible programming language created
by Sun Microsystems, which is currently owned by Oracle. The essential building blocks for
developing Java applications are provided by Core Java, which also includes features, libraries,
and syntax that are shared by all Java platforms.
Key Features of Core Java
• Platform Independence: Core Java applications are designed to be platform-independent,
meaning they can run on any device that has a Java Virtual Machine (JVM) installed.
• Object-Oriented Programming: Java is an object-oriented language, emphasizing the use
of objects and classes for better code organization, reusability, and maintainability.
• Simple and Familiar Syntax: Java syntax is derived from C and C++, making it familiar
to developers from those languages. It also includes simplified features to enhance
readability.
• Robustness and Reliability: Java incorporates features like strong type-checking,
exception handling, and automatic garbage collection, contributing to robust and reliable
applications.
• Security: Java has built-in security features, such as the Java Security Manager, to create
secure applications and applets.
• Multithreading: Core Java supports multithreading, allowing concurrent execution of
multiple threads within a program. This is beneficial for handling parallel tasks.
• Portability: Java programs can be easily ported across different operating systems and
hardware platforms without modification, thanks to its Write Once, Run Anywhere
(WORA) philosophy.
• Rich Standard Library: Core Java comes with a comprehensive standard library (Java
Standard Edition API) that provides a wide range of pre-built classes and packages for
various tasks, from I/O operations to networking.
• Dynamic Memory Allocation: Java manages memory dynamically, and developers do not
need to manually allocate or deallocate memory. The Java Virtual Machine takes care of
memory management.
Core Components of Core Java
• Java Development Kit (JDK): The JDK is a software development kit that includes
everything needed to develop, compile, and run Java applications. It consists of the Java
Runtime Environment (JRE), a compiler, and various development tools.
• Java Virtual Machine (JVM): The JVM is an integral part of Java that interprets and
executes Java bytecode. It provides a runtime environment for Java applications to run on
different platforms.
• Java Standard Edition (SE): Java SE is the core package of the Java programming
language. It includes libraries, APIs, and tools essential for developing Java applications.
 • Language Fundamentals: Core Java covers language fundamentals, including data types,
operators, control structures (if, switch, loops), and syntax rules.
• Object-Oriented Concepts: Concepts such as classes, objects, inheritance, polymorphism,
encapsulation, and abstraction are fundamental to Core Java.
• Exception Handling: Java provides a robust mechanism for handling exceptions and
errors, ensuring proper handling of unexpected situations in the code.
• I/O Operations: Core Java includes libraries for performing input and output operations,
allowing developers to work with files, streams, and network communication.
• Collections Framework: Java's Collections Framework provides a set of classes and
interfaces to store, manipulate, and retrieve collections of objects, such as lists, sets, and
maps.
• Multithreading: Java supports multithreading, enabling the concurrent execution of
multiple threads to enhance the performance and responsiveness of applications.
• Networking: Java provides a rich set of libraries for network programming, allowing
developers to create applications that communicate over the internet.
Core Java serves as the foundation for more advanced Java technologies, including Java Enterprise
Edition (Java EE) for building enterprise-level applications and Java Micro Edition (Java ME) for
mobile and embedded systems. Understanding Core Java is essential for anyone embarking on
Java development.

1.2.Operator
In Java, operators are symbols that perform operations on variables and values. Java supports a
wide range of operators, which can be categorized into several groups based on their functionality.
Here are some common categories of operators in Java:
Arithmetic Operators: Arithmetic operators perform basic mathematical operations.
• Addition (+): Adds two or more operands.
• Subtraction (-): Subtracts the right operand from the left operand.
• Multiplication (*): Multiplies two or more operands.
• Division (/): Divides the left operand by the right operand.
• Modulus (%): Returns the remainder of the division.
int a = 10, b = 3;
int sum = a + b; // 13
int difference = a - b; // 7
int product = a * b; // 30
int quotient = a / b; // 3
int remainder = a % b; // 1
Relational Operators: Relational operators compare two values and return a boolean result.
• Equal to (==): if operands are equal than return true else return false.
 • Not equal to (!=): if operands are not equals than return true else return false.
• Greater than (>): if the right operands are greater than left than return true else return
false.
• Less than (<): if the right operands are less than left than return true else return false.
• Greater than or equal to (>=): if the right operands are greater or equal to left than
return true else return false.
• Less than or equal to (<=): if the right operands are lesser or equal to left than return
true else return false.

int x = 5, y = 8;
boolean isEqual = (x == y); // false
boolean notEqual = (x != y); // true
boolean greaterThan = (x > y); // false
boolean lessThan = (x < y); // true

Logical Operators: Logical operators perform logical operations on boolean values.

• Logical AND (&&): if all operands are true than return true else return false.
• Logical OR ( || ): if any one operand is true than return true else return false.
• Logical NOT (!): if operand is true than return false else return true.

boolean a = true, b = false;

boolean andResult = a && b; // false
boolean orResult = a || b; // true
boolean notResult = !a; // false

Assignment Operators: Assignment operators are used to assign values to variables.

Assignment (=): the right value of equal sign is assigned to left operands of the equal sign.
Add and assign (+=): firstly, addition the right operands of the equal sign and obtained result
assigned to left operands of the equal sign.
Subtract and assign (-=): firstly, subtraction operation performs and the obtained result is
assigned to left operands of the equal sign.
Multiply and assign (*=): firstly, multiply the right operands of the equal sign and obtained
result assigned to left operands of the equal sign.
Divide and assign (/=): firstly, the divide operation performs the right sight of the equal sign,
and obtained result is assigned to left operand from the equal sign.
Modulus and assign (%=): firstly, the modulus operation performs the right sight of the equal
sign that returns a reminder between the operands, and obtained value is assigned to left
operand from the equal sign.
 int x = 5;
x += 3; // x is now 8
x -= 2; // x is now 6
x *= 4; // x is now 24
x /= 3; // x is now 8
x %= 5; // x is now 3

Increment and Decrement Operators: Increment (++) and decrement (--) operators are used
to increase or decrease the value of a variable by 1.
int count = 10;
count++; // Increment by 1, count is now 11
count--; // Decrement by 1, count is now 10

Conditional (Ternary) Operator: The conditional operator is a shorthand way of writing an if-
else statement.
Example
int a = 5, b = 8;
int max = (a > b) ? a : b; // max is assigned the value of a if a > b, otherwise b
These are some of the fundamental operators in Java. Understanding how to use operators is
essential for writing effective and efficient Java code.

1.3. Data type

In Java, data types are used to specify the type of data that a variable can hold. Java has two
categories of data types: primitive data types and reference data types.
Primitive Data Types: Primitive data types are the basic building blocks in Java and represent
simple values. They are directly supported by the language and are not objects.
Integer Types
• byte: 8-bit signed integer (-128 to 127)
• short: 16-bit signed integer (-32,768 to 32,767)
• int: 32-bit signed integer (-2^31 to 2^31 - 1)
• long: 64-bit signed integer (-2^63 to 2^63 - 1)

byte myByte = 10;

short myShort = 1000;
int myInt = 100000;
long myLong = 1000000000L; // Note the 'L' suffix for long literals
Floating-Point Types
• float: 32-bit floating-point number
• double: 64-bit floating-point number (default for decimal values)

float myFloat = 3.14f; // Note the 'f' suffix for float literals
double myDouble = 3.14; // Default for decimal values
Character Type
• char: 16-bit Unicode character

char myChar = 'A';

Boolean Type
• boolean: Represents true or false values
boolean myBoolean = true;

Reference Data Types: Reference data types are more complex and represent objects, which are
instances of classes.
Object Types
String: Represents a sequence of characters (text)
Arrays: Ordered collections of elements
Classes: Custom user-defined types

String myString = "Hello, Java!";

int[] myArray = {1, 2, 3, 4, 5};
MyClass myObject = new MyClass(); // Assuming MyClass is a user-defined class

1.4. Variable

1.5. Arrays
1.6. Methods & Classes
1.7.Inheritance
1.8.Package and Interface
1.9.Exception Handling
1.10. Multithread programming
1.11. I/O
1.12. Java Applet
1.13. String handling
1.14. Event handling
1.15. Introduction to AWT
1.16. AWT controls
1.17. Layout managers