Java is a high-level, class-based, object-oriented programming language designed to have as few implementation dependencies as possible.
It was developed by James Gosling at Sun Microsystems and released in 1995.
Java's "Write Once, Run Anywhere" (WORA) philosophy means code compiled on one platform doesn't need to be recompiled to run on another.
It's widely used in enterprise applications, Android development, web servers, and more.
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Java is powerful!"); // Print a simple message
}
}
Output: Java is powerful!
To begin Java development, install the Java Development Kit (JDK) and a text editor or an Integrated Development Environment (IDE) like IntelliJ or Eclipse.
Ensure you configure the JAVA_HOME environment variable and include the bin directory in your system's PATH so you can compile and run Java programs from the terminal.
C:\> javac HelloWorld.java // Compiles the Java fileOutput: Executes and prints the message inside the Java program.
C:\> java HelloWorld // Runs the compiled class
A basic Java program includes a class with a main method, which serves as the entry point.
The System.out.println() statement is used to display text in the console.
All Java code must reside inside a class and follow proper syntax like semicolons and curly braces.
public class FirstJava {
public static void main(String[] args) {
System.out.println("Hello, Java!");
}
}
Output: Hello, Java!
Java source code is written in .java files and compiled by the javac compiler into bytecode (.class files).
This bytecode is then executed by the Java Virtual Machine (JVM), which makes Java platform-independent.
javac FirstJava.java // Compiles the code into FirstJava.classOutput: Hello, Java!
java FirstJava // Executes the compiled bytecode using JVM
A standard Java program follows a specific structure:
public class StructureExample {
public static void main(String[] args) {
int number = 10; // Declare a variable
if (number > 5) {
System.out.println("Number is greater than 5.");
}
}
}
Output: Number is greater than 5.In Java, variables must be declared with a specific data type. This tells the compiler what kind of data the variable will hold, such as an integer, string, or boolean. Declaration ensures type safety at compile time.
int age = 25;
String name = "Alice";
boolean isStudent = true;
Output: Variables age, name, and isStudent are initialized with values 25, "Alice", and true.
Java has two major types of data: primitive types (like int, float, char) and reference types (like String, arrays, or objects). Primitive types store actual values, while reference types store the memory address of the object.
int score = 90;
double percentage = 88.5;
String greeting = "Hello";
Output: score and percentage are primitives. greeting is a reference to a String object.
Type casting is converting one data type into another. In Java, it can be implicit (automatic widening) or explicit (narrowing conversion). For example, converting from int to double is implicit, but double to int requires explicit casting.
int x = 10;
double y = x; // implicit casting
double a = 9.8;
int b = (int) a; // explicit casting
Output: y becomes 10.0, b becomes 9 (decimal truncated).
Arithmetic operators (+, -, *, /, %) perform mathematical operations. Logical operators (&&, ||, !) are used for boolean logic. They are fundamental in control structures and expressions.
int sum = 5 + 3;
int mod = 10 % 4;
boolean result = (5 > 3) && (4 < 2);
Output: sum = 8, mod = 2, result = false
Java follows specific precedence rules for evaluating expressions. Multiplication and division have higher precedence than addition and subtraction. Associativity determines the order when operators have the same precedence, usually left-to-right.
int result = 10 + 2 * 3;
int grouped = (10 + 2) * 3;
Output: result = 16 (2*3=6 then +10), grouped = 36 ((10+2)=12 then *3)
The if, else if, and else statements allow you to execute different blocks of code depending on various conditions. These control structures help in decision-making based on the evaluation of boolean expressions.
int num = 10;
if (num > 0) {
System.out.println("Positive number");
} else if (num == 0) {
System.out.println("Zero");
} else {
System.out.println("Negative number");
}
Output:
Positive number
The switch statement is used when you need to compare a single variable against multiple values. It is often used for menu selections or when there are many possible conditions to evaluate, making it more efficient than using multiple if-else conditions.
int day = 3;
switch (day) {
case 1:
System.out.println("Monday");
break;
case 2:
System.out.println("Tuesday");
break;
case 3:
System.out.println("Wednesday");
break;
default:
System.out.println("Invalid day");
}
Output:
Wednesday
A while loop repeats a block of code as long as a specified condition is true. It is useful when you do not know in advance how many times the loop should run, and the loop terminates once the condition becomes false.
int count = 0;
while (count < 5) {
System.out.println("Count: " + count);
count++;
}
Output:
Count: 0
Count: 1
Count: 2
Count: 3
Count: 4
The do-while loop is similar to the while loop, except that the block of code is executed at least once before the condition is tested. This guarantees that the code runs at least once, even if the condition is false.
int count = 0;
do {
System.out.println("Count: " + count);
count++;
} while (count < 5);
Output:
Count: 0
Count: 1
Count: 2
Count: 3
Count: 4
A for loop is used when the number of iterations is known. It consists of three parts: initialization, condition, and increment/decrement. Nested loops are used when a loop is placed inside another loop, which is useful for multidimensional data like matrices.
for (int i = 0; i < 3; i++) {
System.out.println("i: " + i);
}
Output:
i: 0
i: 1
i: 2
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.println("i: " + i + ", j: " + j);
}
}
Output:
i: 0, j: 0
i: 0, j: 1
i: 0, j: 2
i: 1, j: 0
i: 1, j: 1
i: 1, j: 2
i: 2, j: 0
i: 2, j: 1
i: 2, j: 2
Methods are functions that are defined within a class. They perform operations using the data from the class and are called using the class object.
# Defining and Calling Methods in Java
class Greeting { // Define a class
public void sayHello() { // Method to print a message
System.out.println("Hello, World!"); // Print message
}
}
public class Main { // Main class
public static void main(String[] args) { // Main method
Greeting greeting = new Greeting(); // Create an object of Greeting class
greeting.sayHello(); // Call the sayHello method
}
}
# Output: Hello, World!
Methods can take input via parameters and return values of specific types. Parameters are passed when calling the method, and the return type defines the kind of data the method will return.
# Method with Parameters and Return Type
class Calculator { // Define a class
public int add(int a, int b) { // Method that takes two parameters and returns an integer
return a + b; // Return the sum
}
}
public class Main { // Main class
public static void main(String[] args) { // Main method
Calculator calc = new Calculator(); // Create a Calculator object
int sum = calc.add(5, 3); // Call the add method with parameters 5 and 3
System.out.println("Sum: " + sum); // Print the result
}
}
# Output: Sum: 8
Method overloading occurs when multiple methods have the same name but differ in parameters. Java determines which method to call based on the number or types of arguments passed.
# Method Overloading in Java
class Printer { // Define a class
public void print(String message) { // Method with one parameter
System.out.println(message); // Print message
}
public void print(int number) { // Method with a different parameter type
System.out.println(number); // Print number
}
}
public class Main { // Main class
public static void main(String[] args) { // Main method
Printer printer = new Printer(); // Create a Printer object
printer.print("Hello, Overloaded!"); // Call method with String parameter
printer.print(123); // Call method with int parameter
}
}
# Output: Hello, Overloaded!
# Output: 123
Recursion is a method calling itself. It is often used to solve problems that can be broken down into smaller, similar problems, such as factorials or tree traversal.
# Recursion Example in Java
class Factorial { // Define a class
public int factorial(int n) { // Recursive method to calculate factorial
if (n == 0) { // Base case: factorial of 0 is 1
return 1; // Return 1
} else { // Recursive case
return n * factorial(n - 1); // Multiply n with factorial of n-1
}
}
}
public class Main { // Main class
public static void main(String[] args) { // Main method
Factorial fact = new Factorial(); // Create a Factorial object
int result = fact.factorial(5); // Call the recursive method with 5
System.out.println("Factorial of 5: " + result); // Print result
}
}
# Output: Factorial of 5: 120
The scope of a variable defines where it can be accessed within the program. The lifetime of a variable determines how long the variable exists in memory. Local variables exist only within the method, while instance variables last as long as the object exists.
# Example of Scope and Lifetime in Java
class ScopeExample { // Define a class
int instanceVar = 10; // Instance variable (object-level)
public void method() { // Method
int localVar = 20; // Local variable (method-level)
System.out.println("Instance Variable: " + instanceVar); // Can access instance variable
System.out.println("Local Variable: " + localVar); // Can access local variable
}
public static void main(String[] args) { // Main method
ScopeExample obj = new ScopeExample(); // Create an object of ScopeExample
obj.method(); // Call method
}
}
# Output: Instance Variable: 10
# Output: Local Variable: 20
# Note: Local variable can't be accessed outside the method where it is defined.
Classes are blueprints for creating objects, while objects are instances of classes. Classes define properties (fields) and behaviors (methods), and objects are the individual entities that have those properties and behaviors.
class Car:
def __init__(self, make, model):
self.make = make
self.model = model
my_car = Car("Toyota", "Corolla")
print(my_car.make, my_car.model)
Output:
Toyota Corolla
Fields are variables within a class that store the state of an object, while methods are functions defined within a class that define the behavior of an object.
class Dog:
def __init__(self, name, breed):
self.name = name
self.breed = breed
def bark(self):
return f"{self.name} says woof!"
my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.bark())
Output:
Buddy says woof!
Constructors are special methods used for initializing the state of an object when it is created. The __init__ method is used as the constructor in Python classes.
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
my_rectangle = Rectangle(10, 5)
print("Area:", my_rectangle.area())
Output:
Area: 50
The this keyword refers to the current instance of the class. In Python, the equivalent is self. It is used to refer to the object's attributes and methods within the class.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
return f"Hello, my name is {self.name} and I am {self.age} years old."
person1 = Person("Alice", 30)
print(person1.greet())
Output:
Hello, my name is Alice and I am 30 years old.
Once a class is defined, you can create multiple objects (instances) of that class. You can also store objects in arrays (or lists in Python) to manage them more easily.
class Product:
def __init__(self, name, price):
self.name = name
self.price = price
# Creating multiple objects
product1 = Product("Laptop", 1000)
product2 = Product("Smartphone", 500)
# Storing objects in a list
products = [product1, product2]
for product in products:
print(f"{product.name}: ${product.price}")
Output:
Laptop: $1000
Smartphone: $500
Getters and Setters are methods used to retrieve (get) and modify (set) the value of private instance variables. This is a way to provide controlled access to these variables from outside the class.
class Person {
private String name;
private int age;
// Getter for name
public String getName() {
return name;
}
// Setter for name
public void setName(String name) {
this.name = name;
}
// Getter for age
public int getAge() {
return age;
}
// Setter for age
public void setAge(int age) {
this.age = age;
}
}
public class Main {
public static void main(String[] args) {
Person person = new Person();
person.setName("John");
person.setAge(30);
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
}
}
Output:
Name: John
Age: 30
In Java, access modifiers are used to set the visibility of classes, methods, and variables. The four types of access modifiers are:
class AccessExample {
private int privateVar = 1;
public int publicVar = 2;
protected int protectedVar = 3;
int defaultVar = 4; // Default access
public void display() {
System.out.println("Private: " + privateVar);
System.out.println("Public: " + publicVar);
System.out.println("Protected: " + protectedVar);
System.out.println("Default: " + defaultVar);
}
}
public class Main {
public static void main(String[] args) {
AccessExample obj = new AccessExample();
obj.display();
}
}
Output:
Private: 1
Public: 2
Protected: 3
Default: 4
JavaBeans is a convention for writing classes that encapsulate data. A JavaBean class should have:
public class PersonBean {
private String name;
private int age;
// Public no-argument constructor
public PersonBean() { }
// Getter for name
public String getName() {
return name;
}
// Setter for name
public void setName(String name) {
this.name = name;
}
// Getter for age
public int getAge() {
return age;
}
// Setter for age
public void setAge(int age) {
this.age = age;
}
}
public class Main {
public static void main(String[] args) {
PersonBean person = new PersonBean();
person.setName("Alice");
person.setAge(25);
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
}
}
Output:
Name: Alice
Age: 25
Immutability refers to an object's state being fixed once it is created. Immutable objects cannot be modified after they are constructed. This is useful for creating thread-safe and reliable code.
final class PersonImmutable {
private final String name;
private final int age;
// Constructor
public PersonImmutable(String name, int age) {
this.name = name;
this.age = age;
}
// Getter for name
public String getName() {
return name;
}
// Getter for age
public int getAge() {
return age;
}
}
public class Main {
public static void main(String[] args) {
PersonImmutable person = new PersonImmutable("John", 30);
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
}
}
Output:
Name: John
Age: 30
Well-encapsulated classes hide their internal details and expose only necessary functionality through public methods. The class should also ensure that its state is consistent at all times.
public class BankAccount {
private double balance;
// Constructor
public BankAccount(double initialBalance) {
if (initialBalance > 0) {
this.balance = initialBalance;
} else {
this.balance = 0;
}
}
// Deposit method
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
// Withdraw method
public void withdraw(double amount) {
if (amount > 0 && balance >= amount) {
balance -= amount;
}
}
// Getter for balance
public double getBalance() {
return balance;
}
}
public class Main {
public static void main(String[] args) {
BankAccount account = new BankAccount(1000);
account.deposit(500);
account.withdraw(200);
System.out.println("Balance: " + account.getBalance());
}
}
Output:
Balance: 1300.0
The `extends` keyword is used in object-oriented programming to create a subclass that inherits properties and methods from a parent class. This allows for code reuse and extension of functionality.
class Animal {
constructor(name) {
this.name = name;
}
speak() {
console.log(this.name + " makes a sound");
}
}
class Dog extends Animal {
constructor(name) {
super(name);
}
speak() {
console.log(this.name + " barks");
}
}
const dog = new Dog("Buddy");
dog.speak();
Output:
Buddy barks
Method Overriding allows a subclass to provide a specific implementation for a method that is already defined in the parent class. It’s used when the subclass needs to customize or extend the behavior of a method.
class Animal {
speak() {
console.log("Animal makes a sound");
}
}
class Dog extends Animal {
speak() {
console.log("Dog barks");
}
}
const dog = new Dog();
dog.speak();
Output:
Dog barks
The `super` keyword is used to call methods or access properties from the parent class. It is particularly useful when you want to override a method in the child class but still call the parent class’s method.
class Animal {
constructor(name) {
this.name = name;
}
speak() {
console.log(this.name + " makes a sound");
}
}
class Dog extends Animal {
constructor(name) {
super(name);
}
speak() {
super.speak();
console.log(this.name + " barks");
}
}
const dog = new Dog("Buddy");
dog.speak();
Output:
Buddy makes a sound
Buddy barks
Polymorphism allows a subclass to implement methods that are called through references of the parent class. Dynamic method dispatch ensures the method that’s executed is based on the object type (not the reference type).
class Animal {
speak() {
console.log("Animal makes a sound");
}
}
class Dog extends Animal {
speak() {
console.log("Dog barks");
}
}
class Cat extends Animal {
speak() {
console.log("Cat meows");
}
}
const animal1 = new Dog();
const animal2 = new Cat();
animal1.speak(); // Dog barks
animal2.speak(); // Cat meows
Output:
Dog barks
Cat meows
Abstract classes and methods are used as templates for other classes. An abstract class cannot be instantiated directly, and abstract methods must be implemented by the subclass.
class Animal {
constructor(name) {
if (this.constructor === Animal) {
throw new Error("Cannot instantiate abstract class");
}
this.name = name;
}
speak() {
throw new Error("Method 'speak()' must be implemented");
}
}
class Dog extends Animal {
speak() {
console.log(this.name + " barks");
}
}
const dog = new Dog("Buddy");
dog.speak();
Output:
Buddy barks
An interface in Java is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. It cannot contain instance fields or constructors. A class implements an interface by providing concrete implementations for the interface's abstract methods.
interface Animal {
void sound(); // Abstract method
}
class Dog implements Animal {
public void sound() {
System.out.println("Bark");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
myDog.sound(); // Output: Bark
}
}
Output:
Bark
A functional interface is an interface that has exactly one abstract method. These interfaces can be implicitly converted to lambda expressions. The `@FunctionalInterface` annotation is used to indicate that the interface is intended to be a functional interface, ensuring that it has only one abstract method.
@FunctionalInterface
interface Calculator {
int add(int a, int b); // Single abstract method
}
public class Main {
public static void main(String[] args) {
// Lambda expression implementing the Calculator interface
Calculator add = (a, b) -> a + b;
System.out.println(add.add(5, 3)); // Output: 8
}
}
Output:
8
Interfaces and abstract classes are similar, but there are key differences. An abstract class can have both abstract and concrete methods, whereas an interface can only have abstract methods (before Java 8) or default and static methods (from Java 8). Abstract classes can have fields, but interfaces cannot.
abstract class Animal {
abstract void sound(); // Abstract method
void sleep() {
System.out.println("Sleeping...");
}
}
interface Movable {
void move(); // Interface method
}
class Dog extends Animal implements Movable {
public void sound() {
System.out.println("Bark");
}
public void move() {
System.out.println("Running");
}
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
dog.sound(); // Output: Bark
dog.sleep(); // Output: Sleeping...
dog.move(); // Output: Running
}
}
Output:
Bark
Sleeping...
Running
In Java 8 and later, interfaces can have default and static methods. A default method has an implementation and can be used by implementing classes. Static methods belong to the interface and can be called without creating an instance of the interface.
interface MyInterface {
default void defaultMethod() {
System.out.println("This is a default method");
}
static void staticMethod() {
System.out.println("This is a static method");
}
}
class MyClass implements MyInterface {
// No need to implement defaultMethod() as it's already provided in the interface
}
public class Main {
public static void main(String[] args) {
MyClass myClass = new MyClass();
myClass.defaultMethod(); // Output: This is a default method
MyInterface.staticMethod(); // Output: This is a static method
}
}
Output:
This is a default method
This is a static method
A class can implement multiple interfaces, and if two interfaces have the same method signature, the class needs to provide its own implementation to resolve the conflict.
interface Animal {
void sound();
}
interface Pet {
void sound(); // Conflict method
}
class Dog implements Animal, Pet {
public void sound() {
System.out.println("Bark");
}
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
dog.sound(); // Output: Bark
}
}
Output:
Bark
In Java, exceptions are classified into two types: checked and unchecked. Checked exceptions are exceptions that the compiler forces you to handle, while unchecked exceptions are exceptions that are not required to be handled explicitly (i.e., runtime exceptions).
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
// Checked Exception (FileNotFoundException)
public class CheckedExceptionExample {
public static void main(String[] args) {
try {
File file = new File("non_existent_file.txt");
Scanner sc = new Scanner(file); // Throws FileNotFoundException
} catch (FileNotFoundException e) {
System.out.println("Checked Exception: File not found!");
}
}
}
// Unchecked Exception (ArithmeticException)
public class UncheckedExceptionExample {
public static void main(String[] args) {
int result = 10 / 0; // Throws ArithmeticException
System.out.println(result);
}
}
Output:
For Checked Exception: "File not found!"
For Unchecked Exception: Throws "ArithmeticException: / by zero".
The try-catch-finally block is used to handle exceptions. The "try" block contains the code that may throw an exception, the "catch" block catches the exception, and the "finally" block executes regardless of whether an exception was thrown or not.
public class TryCatchFinallyExample {
public static void main(String[] args) {
try {
int[] arr = new int[2];
arr[5] = 10; // Throws ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Exception Caught: Index out of bounds!");
} finally {
System.out.println("Finally block executed.");
}
}
}
Output:
"Exception Caught: Index out of bounds!"
"Finally block executed."
In Java, multiple catch blocks can be used to handle different types of exceptions. Each catch block can handle a different type of exception, allowing for more specific handling of different error conditions.
public class MultipleCatchBlocksExample {
public static void main(String[] args) {
try {
int result = 10 / 0; // Throws ArithmeticException
int[] arr = new int[2];
arr[5] = 10; // Throws ArrayIndexOutOfBoundsException
} catch (ArithmeticException e) {
System.out.println("Arithmetic Exception Caught: Division by zero!");
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Array Index Out of Bounds Exception Caught!");
}
}
}
Output:
"Arithmetic Exception Caught: Division by zero!"
The `throw` keyword is used to manually throw an exception. This can be useful when you want to handle specific errors explicitly in your program.
public class ThrowExample {
public static void main(String[] args) {
try {
validateAge(15); // Throws exception if age is less than 18
} catch (IllegalArgumentException e) {
System.out.println("Exception Caught: " + e.getMessage());
}
}
public static void validateAge(int age) {
if (age < 18) {
throw new IllegalArgumentException("Age must be at least 18!");
}
System.out.println("Age is valid.");
}
}
Output:
"Exception Caught: Age must be at least 18!"
In Java, you can create custom exceptions by extending the `Exception` class. This allows you to define your own exception types, making error handling more specific to your application's needs.
class InvalidAgeException extends Exception {
public InvalidAgeException(String message) {
super(message);
}
}
public class CustomExceptionExample {
public static void main(String[] args) {
try {
validateAge(16); // Throws InvalidAgeException
} catch (InvalidAgeException e) {
System.out.println("Custom Exception Caught: " + e.getMessage());
}
}
public static void validateAge(int age) throws InvalidAgeException {
if (age < 18) {
throw new InvalidAgeException("Age must be at least 18!");
}
System.out.println("Age is valid.");
}
}
Output:
"Custom Exception Caught: Age must be at least 18!"
Arrays in Java are used to store multiple values of the same type in a single variable. They have a fixed size once declared.
// Declaring and initializing an array
int[] numbers = {10, 20, 30, 40, 50};
System.out.println(numbers[2]); // Output: 30
Multi-dimensional arrays are arrays of arrays. Commonly used is the 2D array (matrix-like structure).
// 2D Array Example
int[][] matrix = {
{1, 2, 3},
{4, 5, 6}
};
System.out.println(matrix[1][2]); // Output: 6
The `String` class in Java is immutable. It provides many useful methods to manipulate strings.
// Common String methods
String name = "Java Programming";
System.out.println(name.length()); // Output: 16
System.out.println(name.toUpperCase()); // Output: JAVA PROGRAMMING
System.out.println(name.contains("Pro")); // Output: true
`StringBuilder` and `StringBuffer` are mutable alternatives to `String`. `StringBuffer` is thread-safe while `StringBuilder` is faster for single-threaded applications.
// Using StringBuilder
StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
System.out.println(sb); // Output: Hello World
// Using StringBuffer
StringBuffer sbf = new StringBuffer("Data");
sbf.insert(4, "Base");
System.out.println(sbf); // Output: DataBase
`ArrayList` is a part of the Java Collection Framework and is dynamic in size, unlike arrays which have a fixed size.
// Using Array
String[] fruits = {"Apple", "Banana", "Mango"};
System.out.println(fruits[1]); // Output: Banana
// Using ArrayList
import java.util.ArrayList;
ArrayList<String> fruitList = new ArrayList<>();
fruitList.add("Apple");
fruitList.add("Banana");
fruitList.add("Mango");
System.out.println(fruitList.get(1)); // Output: Banana
The Java Collections Framework provides several interfaces to store and manipulate data.
The three main interfaces are:
import java.util.ArrayList;Output: Alice
import java.util.List;
public class ListExample {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Alice"); // Adds an element to the list
names.add("Bob");
names.add("Charlie");
for (String name : names) {
System.out.println(name); // Iterates and prints each name
}
}
}
Java offers various implementations of the Collection interfaces.
import java.util.LinkedList;Output: Java
import java.util.List;
public class LinkedListExample {
public static void main(String[] args) {
List<String> list = new LinkedList<>();
list.add("Java");
list.add("Python");
list.add("JavaScript");
for (String language : list) {
System.out.println(language);
}
}
}
These are all implementations of the Map interface.
import java.util.HashMap;Output: Apple: 1
import java.util.Map;
public class HashMapExample {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Orange", 3);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}
Java provides several ways to iterate over collections:
import java.util.List;Output: A
import java.util.ArrayList;
public class ForEachExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
list.forEach(item -> System.out.println(item)); // Using forEach with lambda
}
}
Collections can be sorted and searched in Java.
Collections.sort() for Lists or TreeSet for Sets.Collections.binarySearch() for sorted lists.import java.util.Collections;Output: 1
import java.util.List;
import java.util.ArrayList;
public class SortExample {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(3);
numbers.add(1);
numbers.add(2);
Collections.sort(numbers); // Sort the list
for (Integer number : numbers) {
System.out.println(number);
}
}
}
The FileReader and FileWriter classes are used to read and write data from and to text files. FileReader is used for reading character data, while FileWriter is used for writing characters to files.
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
try {
FileReader reader = new FileReader("input.txt");
FileWriter writer = new FileWriter("output.txt");
int data;
while ((data = reader.read()) != -1) {
writer.write(data);
}
reader.close();
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
Output: The contents of "input.txt" are copied to "output.txt".
The BufferedReader and BufferedWriter classes are used for reading and writing text efficiently. These classes allow you to read or write data in larger chunks, which can improve performance when working with larger files.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
try {
BufferedReader br = new BufferedReader(new FileReader("input.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
}
br.close();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
Output: The lines of "input.txt" are read and written to "output.txt" with buffering.
Object serialization is the process of converting an object into a byte stream. Deserialization is the reverse process, where the byte stream is converted back into an object. This is useful for saving objects to a file or sending them over a network.
import java.io.Serializable;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
class Person implements Serializable {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
try {
Person p = new Person("John", 30);
FileOutputStream fos = new FileOutputStream("person.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(p);
oos.close();
FileInputStream fis = new FileInputStream("person.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
Person deserializedPerson = (Person) ois.readObject();
System.out.println("Name: " + deserializedPerson.name + ", Age: " + deserializedPerson.age);
ois.close();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
Output: The person object is serialized to a file and deserialized to print out the person's name and age.
The New Input/Output (NIO) package provides faster and more scalable I/O operations. It includes classes like Path, Files, and FileChannel for working with files and directories.
import java.nio.file.*;
import java.io.IOException;
try {
Path path = Paths.get("file.txt");
String content = new String(Files.readAllBytes(path));
System.out.println(content);
Files.write(path, "New content".getBytes());
} catch (IOException e) {
e.printStackTrace();
}
Output: The contents of "file.txt" are read and then new content is written to the file using NIO.
Exception handling is crucial when dealing with file operations to ensure that issues such as missing files or read/write errors are handled gracefully.
import java.io.File;
import java.io.IOException;
try {
File file = new File("nonexistentfile.txt");
if (!file.exists()) {
throw new IOException("File not found");
}
} catch (IOException e) {
System.out.println(e.getMessage());
}
Output: If the file doesn't exist, an IOException is thrown with the message "File not found".
In Java, threads can be created by either extending the Thread class or implementing the Runnable interface. Extending Thread is straightforward and is used when you want to override the run() method directly. Implementing Runnable is more flexible as it allows you to implement the run() method in a separate class, which can then be passed to a thread for execution.
class MyThread extends Thread {
public void run() {
System.out.println("Thread is running...");
}
}
public class Main {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
}
}
Output:
Thread is running...
class MyRunnable implements Runnable {
public void run() {
System.out.println("Thread is running...");
}
}
public class Main {
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();
}
}
Output:
Thread is running...
Threads in Java go through several states during their lifecycle: New, Runnable, Blocked, Waiting, Timed Waiting, and Terminated. The thread is in the "New" state when it is created but not yet started. It moves to "Runnable" once start() is called, and the thread scheduler picks it up. The thread enters "Blocked" when it is waiting for resources or locks, and it enters "Waiting" when it waits indefinitely for another thread to perform a particular action.
class MyThread extends Thread {
public void run() {
System.out.println("Thread started...");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
System.out.println("Thread interrupted...");
}
System.out.println("Thread finished...");
}
}
public class Main {
public static void main(String[] args) throws InterruptedException {
MyThread thread = new MyThread();
System.out.println("Thread state before start: " + thread.getState());
thread.start();
Thread.sleep(1000);
System.out.println("Thread state after 1 second: " + thread.getState());
thread.join();
System.out.println("Thread state after completion: " + thread.getState());
}
}
Output:
Thread state before start: NEW
Thread started...
Thread state after 1 second: TIMED_WAITING
Thread finished...
Thread state after completion: TERMINATED
Synchronization in Java is used to control access to a shared resource by multiple threads. If multiple threads access the same resource, it can lead to race conditions. The synchronized keyword ensures that only one thread can access a method or block of code at a time. Locks provide more advanced control, allowing finer-grained control over synchronization.
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public int getCount() {
return count;
}
}
public class Main {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Runnable task = () -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
};
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final count: " + counter.getCount());
}
}
Output:
Final count: 2000
Inter-thread communication in Java is used when threads need to communicate with each other, such as when one thread needs to wait for another thread to complete an operation. The methods wait(), notify(), and notifyAll() are used for this purpose. These methods must be called within a synchronized block.
class SharedResource {
public synchronized void produce() throws InterruptedException {
System.out.println("Produced item...");
notify();
wait();
}
public synchronized void consume() throws InterruptedException {
wait();
System.out.println("Consumed item...");
notify();
}
}
public class Main {
public static void main(String[] args) throws InterruptedException {
SharedResource resource = new SharedResource();
Thread producer = new Thread(() -> {
try {
resource.produce();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
Thread consumer = new Thread(() -> {
try {
resource.consume();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
producer.start();
consumer.start();
producer.join();
consumer.join();
}
}
Output:
Produced item...
Consumed item...
Executors provide a higher-level replacement for managing threads in Java. They handle thread creation, scheduling, and management for you. The Callable interface is similar to Runnable but allows for returning a result. Future represents the result of an asynchronous computation.
import java.util.concurrent.*;
public class Main {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executor = Executors.newFixedThreadPool(2);
Callabletask = () -> {
return 100;
};
Futureresult = executor.submit(task);
System.out.println("Result: " + result.get());
executor.shutdown();
}
}
Output:
Result: 100
Swing is a part of Java's Standard Library used for creating graphical user interfaces (GUIs). The JFrame is a top-level container used to hold components like buttons, text fields, and labels in a window.
# Basic Swing and JFrame Example
import javax.swing.*; // Import Swing package
public class Main { // Main class
public static void main(String[] args) { // Main method
JFrame frame = new JFrame("Swing Application"); // Create a JFrame with title
frame.setSize(300, 200); // Set the window size
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Close operation
frame.setVisible(true); // Make the frame visible
}
}
# Output: A simple window titled "Swing Application".
Buttons, labels, and text fields are common components added to a Swing interface. Buttons trigger actions, labels display text, and text fields allow user input.
# Adding Buttons, Labels, and Text Fields in Swing
import javax.swing.*; // Import Swing package
public class Main { // Main class
public static void main(String[] args) { // Main method
JFrame frame = new JFrame("Swing Application"); // Create a JFrame
frame.setSize(400, 300); // Set window size
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Close operation
JButton button = new JButton("Click Me!"); // Create a button
JLabel label = new JLabel("Enter your name:"); // Create a label
JTextField textField = new JTextField(); // Create a text field
frame.setLayout(new FlowLayout()); // Use FlowLayout for simple layout
frame.add(label); // Add label to frame
frame.add(textField); // Add text field to frame
frame.add(button); // Add button to frame
frame.setVisible(true); // Make frame visible
}
}
# Output: A window with a label, text field, and button.
Layout managers control the placement and size of components within a container. Different managers offer different arrangements for components. Common layout managers include FlowLayout, BorderLayout, GridLayout, and more.
# Using Layout Managers in Swing
import javax.swing.*; // Import Swing package
public class Main { // Main class
public static void main(String[] args) { // Main method
JFrame frame = new JFrame("Layout Example"); // Create JFrame
frame.setSize(400, 200); // Set window size
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Close operation
frame.setLayout(new BorderLayout()); // Set BorderLayout manager
JButton northButton = new JButton("North"); // Button in the North region
JButton southButton = new JButton("South"); // Button in the South region
frame.add(northButton, BorderLayout.NORTH); // Add button to North
frame.add(southButton, BorderLayout.SOUTH); // Add button to South
frame.setVisible(true); // Make frame visible
}
}
# Output: A window with buttons aligned at the top (North) and bottom (South).
Event handling allows you to capture user interactions such as clicks, key presses, and window changes. Listeners are used to respond to these events and trigger specific actions.
# Event Handling with ActionListener in Swing
import javax.swing.*; // Import Swing package
import java.awt.event.*; // Import ActionListener package
public class Main { // Main class
public static void main(String[] args) { // Main method
JFrame frame = new JFrame("Event Handling Example"); // Create JFrame
frame.setSize(400, 300); // Set window size
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Close operation
JButton button = new JButton("Click Me!"); // Create a button
// Add ActionListener to button
button.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { // Event triggered when button is clicked
JOptionPane.showMessageDialog(frame, "Button Clicked!"); // Show dialog box
}
});
frame.setLayout(new FlowLayout()); // Use FlowLayout
frame.add(button); // Add button to frame
frame.setVisible(true); // Make frame visible
}
}
# Output: A window with a button. When clicked, a message box appears saying "Button Clicked!".
Building a GUI application involves combining all the components and handling events, allowing for user interaction. A simple application can be created by integrating the use of buttons, labels, text fields, and event listeners.
# Simple Java GUI Application Example
import javax.swing.*; // Import Swing package
import java.awt.event.*; // Import ActionListener package
public class Main { // Main class
public static void main(String[] args) { // Main method
JFrame frame = new JFrame("Simple GUI Application"); // Create JFrame
frame.setSize(400, 300); // Set window size
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Close operation
JLabel label = new JLabel("Enter your name:"); // Label for user input
JTextField textField = new JTextField(); // Text field for name input
JButton button = new JButton("Submit"); // Submit button
button.addActionListener(new ActionListener() { // ActionListener for the button
public void actionPerformed(ActionEvent e) { // Action when button is clicked
String name = textField.getText(); // Get text from text field
JOptionPane.showMessageDialog(frame, "Hello, " + name + "!"); // Display greeting
}
});
frame.setLayout(new FlowLayout()); // FlowLayout for components
frame.add(label); // Add label to frame
frame.add(textField); // Add text field to frame
frame.add(button); // Add button to frame
frame.setVisible(true); // Make frame visible
}
}
# Output: A window with a text field and a button. When the user enters their name and clicks Submit, a greeting appears.
Networking allows computers to communicate over a network. Sockets are used to enable communication between devices over a network. A socket is an endpoint for sending or receiving data across a computer network.
import java.net.*;
import java.io.*;
public class SimpleServer {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(1234);
System.out.println("Server started. Waiting for clients...");
Socket clientSocket = serverSocket.accept();
System.out.println("Client connected!");
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Output:
Server started. Waiting for clients...
Client connected!
Client-server communication involves the exchange of messages between a client (requester) and a server (provider). The client sends a request, and the server responds with the requested data or a message.
import java.net.*;
import java.io.*;
public class SimpleClient {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost", 1234);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("Hello Server!");
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Output:
Client sends a message "Hello Server!" to the server.
URLs (Uniform Resource Locators) are used to access resources on the web. HTTP requests are used to communicate with web servers, typically to fetch data or send information.
import java.net.*;
import java.io.*;
public class HttpClient {
public static void main(String[] args) {
try {
URL url = new URL("http://www.example.com");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println(inputLine);
}
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Output:
The HTML content of the page at "http://www.example.com" is printed to the console.
A multi-threaded server can handle multiple client requests at the same time by creating a new thread for each client connection. This allows the server to be more efficient and responsive.
import java.net.*;
import java.io.*;
public class MultiThreadedServer {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(1234);
System.out.println("Server started. Waiting for clients...");
while (true) {
Socket clientSocket = serverSocket.accept();
new ClientHandler(clientSocket).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
static class ClientHandler extends Thread {
private Socket socket;
public ClientHandler(Socket socket) {
this.socket = socket;
}
public void run() {
try {
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("Hello from the server!");
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Output:
Each connected client will receive "Hello from the server!"
A chat application enables real-time communication between users. In Java, a basic chat application can be built using sockets and multi-threading.
import java.net.*;
import java.io.*;
public class ChatServer {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(1234);
System.out.println("Chat Server started. Waiting for clients...");
while (true) {
Socket clientSocket = serverSocket.accept();
new ChatHandler(clientSocket).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
static class ChatHandler extends Thread {
private Socket socket;
public ChatHandler(Socket socket) {
this.socket = socket;
}
public void run() {
try {
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
String message;
while ((message = in.readLine()) != null) {
System.out.println("Client says: " + message);
out.println("Server: " + message);
}
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Output:
The chat server will print messages from the client and echo them back.
JDBC (Java Database Connectivity) is a Java API that allows Java programs to connect and interact with databases. JDBC drivers are platform-specific implementations that enable the connection between a Java application and a database. There are four types of JDBC drivers:
/* JDBC Example: Database Connection */
import java.sql.*;
public class JDBCExample {
public static void main(String[] args) {
try {
// Load the JDBC driver (for MySQL database)
Class.forName("com.mysql.cj.jdbc.Driver");
// Create a connection to the database
Connection con = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/mydatabase", "username", "password");
// Create a statement to interact with the database
Statement stmt = con.createStatement();
// Execute a query
ResultSet rs = stmt.executeQuery("SELECT * FROM users");
// Process the results
while (rs.next()) {
System.out.println(rs.getString("username"));
}
// Close the resources
rs.close();
stmt.close();
con.close();
} catch (Exception e) {
System.out.println(e);
}
}
}
Output:
(Assuming the table "users" contains data)
username
user1
user2
user3
To connect to a database in Java, you need to load the appropriate JDBC driver, obtain a database connection using the `DriverManager.getConnection()` method, and provide the necessary credentials such as URL, username, and password.
import java.sql.*;
public class ConnectToDatabase {
public static void main(String[] args) {
try {
// Load MySQL JDBC driver
Class.forName("com.mysql.cj.jdbc.Driver");
// Establish the connection to the database
Connection con = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/mydatabase", "root", "password");
// Check if connection was successful
if (con != null) {
System.out.println("Connection successful!");
}
// Close the connection
con.close();
} catch (Exception e) {
System.out.println(e);
}
}
}
Output:
Connection successful!
Once a connection is established, you can execute SQL queries using the `Statement` or `PreparedStatement` objects. For querying, `executeQuery()` is used, and for updates, `executeUpdate()` is used.
import java.sql.*;
public class ExecuteQueryUpdate {
public static void main(String[] args) {
try {
// Load MySQL JDBC driver
Class.forName("com.mysql.cj.jdbc.Driver");
// Establish connection
Connection con = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/mydatabase", "root", "password");
// Create a Statement object
Statement stmt = con.createStatement();
// Execute an update (INSERT, UPDATE, DELETE)
String updateQuery = "UPDATE users SET age = 30 WHERE username = 'user1'";
int rowsAffected = stmt.executeUpdate(updateQuery);
System.out.println(rowsAffected + " rows updated.");
// Execute a query (SELECT)
String selectQuery = "SELECT * FROM users";
ResultSet rs = stmt.executeQuery(selectQuery);
while (rs.next()) {
System.out.println(rs.getString("username") + ": " + rs.getInt("age"));
}
// Close resources
rs.close();
stmt.close();
con.close();
} catch (Exception e) {
System.out.println(e);
}
}
}
Output:
1 rows updated.
user1: 30
user2: 25
user3: 28
The `PreparedStatement` is used to execute precompiled SQL statements. It helps prevent SQL injection attacks and improves performance. Additionally, database transactions allow you to group multiple operations into a single unit, which can be committed or rolled back as needed.
import java.sql.*;
public class PreparedStatementTransaction {
public static void main(String[] args) {
Connection con = null;
PreparedStatement pstmt = null;
try {
// Load MySQL JDBC driver
Class.forName("com.mysql.cj.jdbc.Driver");
// Establish connection
con = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/mydatabase", "root", "password");
// Disable auto-commit for transaction
con.setAutoCommit(false);
// Prepare SQL statements
String updateQuery = "UPDATE users SET age = ? WHERE username = ?";
pstmt = con.prepareStatement(updateQuery);
pstmt.setInt(1, 35);
pstmt.setString(2, "user1");
// Execute update
int rowsAffected = pstmt.executeUpdate();
System.out.println(rowsAffected + " rows updated.");
// Commit transaction
con.commit();
} catch (Exception e) {
// Rollback transaction in case of an error
try {
if (con != null) {
con.rollback();
}
} catch (SQLException ex) {
System.out.println(ex);
}
System.out.println(e);
} finally {
try {
if (pstmt != null) pstmt.close();
if (con != null) con.close();
} catch (SQLException ex) {
System.out.println(ex);
}
}
}
}
Output:
1 rows updated.
CRUD operations (Create, Read, Update, Delete) are the four basic functions of persistent storage in a database. Java provides various ways to perform these operations using JDBC.
import java.sql.*;
public class CRUDOperations {
public static void main(String[] args) {
try {
// Load MySQL JDBC driver
Class.forName("com.mysql.cj.jdbc.Driver");
// Establish connection
Connection con = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/mydatabase", "root", "password");
// Create
String insertQuery = "INSERT INTO users (username, age) VALUES (?, ?)";
PreparedStatement pstmt = con.prepareStatement(insertQuery);
pstmt.setString(1, "newuser");
pstmt.setInt(2, 22);
pstmt.executeUpdate();
// Read
String selectQuery = "SELECT * FROM users";
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(selectQuery);
while (rs.next()) {
System.out.println(rs.getString("username") + ": " + rs.getInt("age"));
}
// Update
String updateQuery = "UPDATE users SET age = ? WHERE username = ?";
pstmt = con.prepareStatement(updateQuery);
pstmt.setInt(1, 30);
pstmt.setString(2, "newuser");
pstmt.executeUpdate();
// Delete
String deleteQuery = "DELETE FROM users WHERE username = ?";
pstmt = con.prepareStatement(deleteQuery);
pstmt.setString(1, "newuser");
pstmt.executeUpdate();
// Close resources
rs.close();
pstmt.close();
stmt.close();
con.close();
} catch (Exception e) {
System.out.println(e);
}
}
}
Output:
(After execution of queries)
username: age
Java provides several built-in annotations such as `@Override` and `@Deprecated` to indicate special behaviors. `@Override` ensures that a method is overriding a method in the superclass, while `@Deprecated` marks a method or class as outdated.
class Animal {
void speak() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
@Override // Indicates this method overrides the parent class's method
void speak() {
System.out.println("Dog barks");
}
}
class OldClass {
@Deprecated // Marks this method as outdated
void oldMethod() {
System.out.println("This method is deprecated");
}
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
dog.speak();
OldClass old = new OldClass();
old.oldMethod(); // Compiler will warn that this method is deprecated
}
}
Output:
Dog barks
This method is deprecated
Custom annotations allow you to create your own annotations for specific tasks. You can define the retention policy and target of the annotation.
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME) // Indicates that this annotation will be available at runtime
@interface MyCustomAnnotation {
String value() default "Default Value";
}
@MyCustomAnnotation(value = "Custom Annotation Example")
class MyClass {
void display() {
System.out.println("Displaying from MyClass");
}
}
public class Main {
public static void main(String[] args) {
MyClass obj = new MyClass();
obj.display();
MyCustomAnnotation annotation = obj.getClass().getAnnotation(MyCustomAnnotation.class);
System.out.println("Annotation Value: " + annotation.value());
}
}
Output:
Displaying from MyClass
Annotation Value: Custom Annotation Example
Reflection in Java allows you to inspect and manipulate classes, methods, and fields at runtime. You can use reflection to get information about a class, its methods, and its constructors.
import java.lang.reflect.*;
class Animal {
void speak() {
System.out.println("Animal makes a sound");
}
}
public class Main {
public static void main(String[] args) throws Exception {
Animal animal = new Animal();
Class clazz = animal.getClass(); // Get class object using reflection
System.out.println("Class Name: " + clazz.getName());
System.out.println("Methods: ");
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method.getName());
}
}
}
Output:
Class Name: Animal
Methods:
speak
Reflection also allows you to dynamically access and invoke methods and fields of a class. This can be useful for frameworks or tools that work with objects in a generic way.
import java.lang.reflect.*;
class Animal {
private String name;
Animal(String name) {
this.name = name;
}
void speak() {
System.out.println(this.name + " makes a sound");
}
}
public class Main {
public static void main(String[] args) throws Exception {
Animal animal = new Animal("Buddy");
Class clazz = animal.getClass();
Method speakMethod = clazz.getDeclaredMethod("speak");
Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true); // Access private field
System.out.println("Name: " + nameField.get(animal));
speakMethod.invoke(animal); // Invoke method dynamically
}
}
Output:
Name: Buddy
Buddy makes a sound
Annotation processing allows you to process annotations at runtime and perform certain actions based on the annotations present in your code.
import java.lang.annotation.*;
import java.lang.reflect.*;
@Retention(RetentionPolicy.RUNTIME)
@interface CustomAnnotation {
String info();
}
@CustomAnnotation(info = "This is a custom annotation")
class MyClass {
void display() {
System.out.println("Displaying from MyClass");
}
}
public class Main {
public static void main(String[] args) throws Exception {
MyClass obj = new MyClass();
obj.display();
Class clazz = obj.getClass();
CustomAnnotation annotation = clazz.getAnnotation(CustomAnnotation.class);
System.out.println("Annotation Info: " + annotation.info());
}
}
Output:
Displaying from MyClass
Annotation Info: This is a custom annotation
A lambda expression is a short block of code that takes in parameters and returns a value. Lambda expressions can be used to implement methods of functional interfaces, and they provide a clear and concise way to represent one method interfaces (functional interfaces) using an expression.
interface Greeting {
void greet(String name);
}
public class Main {
public static void main(String[] args) {
// Lambda expression to implement the greet method
Greeting greetMessage = name -> System.out.println("Hello, " + name);
greetMessage.greet("John"); // Output: Hello, John
}
}
Output:
Hello, John
Method references in Java provide a way to refer to a method without invoking it. Constructor references are a special type of method reference used to call constructors.
interface Printer {
void print(String message);
}
class PrinterImpl {
public void printMessage(String message) {
System.out.println(message);
}
}
public class Main {
public static void main(String[] args) {
Printer printer = new PrinterImpl()::printMessage; // Method reference
printer.print("Method Reference Example"); // Output: Method Reference Example
}
}
Output:
Method Reference Example
interface PersonFactory {
Person createPerson(String name);
}
class Person {
private String name;
public Person(String name) {
this.name = name;
}
public void greet() {
System.out.println("Hello, " + name);
}
}
public class Main {
public static void main(String[] args) {
// Constructor reference
PersonFactory personFactory = Person::new;
Person person = personFactory.createPerson("Alice");
person.greet(); // Output: Hello, Alice
}
}
Output:
Hello, Alice
The Streams API in Java provides a high-level abstraction for processing sequences of elements (such as collections). It supports functional-style operations like map, filter, reduce, and collect, making it easy to process data in a declarative way.
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
Listnumbers = Arrays.asList(1, 2, 3, 4, 5);
ListevenNumbers = numbers.stream()
.filter(n -> n % 2 == 0) // Filter even numbers
.collect(Collectors.toList());
System.out.println(evenNumbers); // Output: [2, 4]
}
}
Output:
[2, 4]
Functional interfaces are interfaces with a single abstract method. Java provides several built-in functional interfaces such as `Predicate`, `Consumer`, `Function`, and `Supplier`, which can be used with lambda expressions and method references.
import java.util.function.Predicate;
public class Main {
public static void main(String[] args) {
PredicateisEven = n -> n % 2 == 0;
System.out.println(isEven.test(4)); // Output: true
System.out.println(isEven.test(5)); // Output: false
}
}
Output:
true
false
import java.util.function.Consumer;
public class Main {
public static void main(String[] args) {
ConsumerprintMessage = message -> System.out.println(message);
printMessage.accept("Hello, World!"); // Output: Hello, World!
}
}
Output:
Hello, World!
The `Optional` class is a container object which may or may not contain a value. It is used to avoid null references and helps in reducing `NullPointerExceptions` in code. Methods like `ifPresent()`, `orElse()`, and `map()` are commonly used with `Optional` objects.
import java.util.Optional;
public class Main {
public static void main(String[] args) {
OptionaloptionalValue = Optional.of("Java");
optionalValue.ifPresent(value -> System.out.println(value)); // Output: Java
OptionalemptyValue = Optional.empty();
System.out.println(emptyValue.orElse("Default Value")); // Output: Default Value
}
}
Output:
Java
Default Value
Java 9 introduced the concept of modules, which provides a way to group related packages together and control the visibility of these packages to other modules. Modules help in better organizing and managing large applications by making them more maintainable, scalable, and secure.
module mymodule {
// This defines a simple module
requires java.base; // This module requires the base module
exports com.example; // This exports the com.example package for others to use
}
Explanation:
The `module` keyword is used to define a module. Inside the module, `requires` specifies dependencies on other modules, and `exports` makes packages from this module available for other modules to use.
To create a module, you need to add a `module-info.java` file in the root of your module directory. This file defines the module and its dependencies or packages that it exports to other modules.
module mymodule {
requires java.logging; // Requires the java.logging module
exports com.mypackage; // Exports the com.mypackage package to other modules
}
Explanation:
The `module-info.java` file is used to define a module's dependencies (with `requires`) and to expose certain packages (with `exports`). The module can be used by other modules that require it.
In Java modular programming, a module can export its packages to make them accessible to other modules. Similarly, a module can require other modules to access their functionalities. This modularity allows for better management of dependencies.
module com.example.moduleA {
requires java.sql; // This module requires the java.sql module
exports com.example.a; // This exports the com.example.a package
}
module com.example.moduleB {
requires com.example.moduleA; // This module requires com.example.moduleA
exports com.example.b; // This exports the com.example.b package
}
Explanation:
Here, `moduleA` exports its package `com.example.a`, making it accessible to other modules. `moduleB` requires `moduleA` to use its exported packages.
Java 9 allows non-modular JAR files to be treated as modules through the concept of automatic modules. These modules are automatically assigned a module name based on the JAR filename. They can be used in the modular system without needing a `module-info.java` file.
javac -d mods/com.example.moduleA src/com/example/moduleA/*.java
jar --create --file=mods/com.example.moduleA.jar -C bin .
// In module-info.java
module com.example.moduleB {
requires com.example.moduleA; // Using automatic module com.example.moduleA
exports com.example.b;
}
Explanation:
In this example, we treat the JAR `com.example.moduleA.jar` as an automatic module. It is included in the module path and can be required by other modules like `moduleB`.
When migrating a traditional Java project to Java 9 modules, you need to define module boundaries and update your project structure. This includes creating the `module-info.java` file and adjusting dependencies. Migration may require refactoring existing code to adapt to the module system.
module com.example.app {
requires com.example.utils; // Requires the utils module
exports com.example.app;
}
// refactor code to follow module rules
// Now ensure that no packages are accessed from outside the module without being explicitly exported
Explanation:
Migration involves creating modules and adding `module-info.java`. For the `com.example.app` module, it requires the `com.example.utils` module. You need to adjust code to fit the modular structure and ensure proper package visibility.
Generics allow Java classes and methods to operate on objects of various types while providing compile-time type safety. This means fewer runtime errors and more robust code.
// A simple generic class
class Box<T> {
private T content;
public void set(T content) { this.content = content; }
public T get() { return content; }
}
public class Main {
public static void main(String[] args) {
Box<String> stringBox = new Box<>();
stringBox.set("Hello Generics");
System.out.println(stringBox.get()); // Output: Hello Generics
}
}
The Java Memory Model defines how threads interact through memory. The Garbage Collector (GC) automatically reclaims unused memory, preventing memory leaks.
// Demonstrating garbage collection
public class GCExample {
public static void main(String[] args) {
GCExample obj = new GCExample();
obj = null; // Object eligible for GC
System.gc();
System.out.println("Garbage collection requested");
}
protected void finalize() {
System.out.println("GC cleaned up the object");
}
}
Design Patterns are reusable solutions to common software design problems. The Singleton ensures only one instance of a class exists, while Factory creates objects without specifying exact class names.
// Singleton Pattern Example
class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) instance = new Singleton();
return instance;
}
}
public class Main {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2); // Output: true
}
}
Performance can be optimized by reducing memory usage, using efficient algorithms, avoiding unnecessary object creation, and leveraging built-in tools like JMH for benchmarking.
// Avoiding object creation inside loop
public class Optimize {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 5; i++) {
sb.append(i);
}
System.out.println(sb.toString()); // Output: 01234
}
}
Java projects can be built into JAR files and managed using build tools like Maven or Gradle. These tools handle dependencies and automate the build process.
// Command to create a JAR (from terminal)
// javac Main.java
// jar cfe MyApp.jar Main Main.class
// java -jar MyApp.jar
// Maven POM snippet
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>myapp</artifactId>
<version>1.0</version>
</project>
// Gradle build.gradle snippet
plugins {
id 'java'
}
group = 'com.example'
version = '1.0'
Design patterns are solutions to common design problems. Creational patterns deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The most common creational patterns include:
class Singleton {
private static Singleton instance;
private Singleton() {} // Private constructor
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
public class Main {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2); // Will print true, because both are same instance
}
}
Output: trueStructural patterns deal with object composition, helping to assemble objects and classes into larger structures. The key patterns include:
interface Shape {
void draw();
}
class Circle implements Shape {
public void draw() {
System.out.println("Drawing Circle");
}
}
class ShapeAdapter implements Shape {
private Rectangle rectangle;
public ShapeAdapter(Rectangle rectangle) {
this.rectangle = rectangle;
}
public void draw() {
rectangle.draw(); // Adapt Rectangle to work as Shape
}
}
class Rectangle {
public void draw() {
System.out.println("Drawing Rectangle");
}
}
public class Main {
public static void main(String[] args) {
Shape circle = new Circle();
Shape rectangleAdapter = new ShapeAdapter(new Rectangle());
circle.draw(); // Output: Drawing Circle
rectangleAdapter.draw(); // Output: Drawing Rectangle
}
}
Output: Drawing CircleBehavioral patterns focus on communication between objects, helping to define the interactions and responsibilities. The most commonly used patterns include:
interface Observer {
void update(String message);
}
class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
public void update(String message) {
System.out.println(name + " received: " + message);
}
}
class Subject {
private List<Observer> observers = new ArrayList<>();
public void addObserver(Observer observer) {
observers.add(observer);
}
public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}
public class Main {
public static void main(String[] args) {
Subject subject = new Subject();
Observer observer1 = new ConcreteObserver("Observer 1");
Observer observer2 = new ConcreteObserver("Observer 2");
subject.addObserver(observer1);
subject.addObserver(observer2);
subject.notifyObservers("Hello Observers!");
}
}
Output: Observer 1 received: Hello Observers!In real-world software development, design patterns are widely used to solve common problems. These patterns offer best practices that are efficient and reusable. For example:
Choosing the right design pattern depends on the problem at hand. Here's a guide to help decide:
The Java Memory Model defines how memory is organized in the JVM, including the heap, stack, and metaspace. The heap stores objects, the stack stores method frames, and metaspace stores class metadata.
public class MemoryModelExample {
public static void main(String[] args) {
String str = "Hello, World!"; // Object stored in Heap
int x = 10; // Primitive stored in Stack
}
}
Output: The string "Hello, World!" is stored in the heap, and the integer 10 is stored in the stack.
Java provides various garbage collection algorithms, each designed to optimize memory management. G1, CMS, and ZGC are some of the most commonly used collectors in modern Java applications.
# G1 GC example configuration java -XX:+UseG1GC -jar MyApp.jar
# CMS GC example configuration java -XX:+UseConcMarkSweepGC -jar MyApp.jar
# ZGC GC example configuration java -XX:+UseZGC -jar MyApp.jar
Output: The Java application will run using the selected garbage collection algorithm (G1, CMS, or ZGC).
JVM monitoring tools, such as JConsole and VisualVM, allow developers to observe and analyze the performance of their Java applications in real-time, focusing on memory usage, CPU performance, and thread activity.
# Run VisualVM with a running Java application jvisualvm -J-Duser.library.path=-cp
# Run JConsole with a running Java application jconsole
Output: VisualVM or JConsole will connect to the Java process and provide a graphical interface for monitoring its performance and memory usage.
JVM options and performance flags are used to fine-tune the behavior of the JVM. These flags control aspects such as garbage collection, heap size, and thread management.
# Set the initial heap size to 1GB and max heap size to 2GB java -Xms1g -Xmx2g -jar MyApp.jar
# Enable garbage collection logging java -Xlog:gc* -jar MyApp.jar
# Set the thread stack size to 512KB java -Xss512k -jar MyApp.jar
Output: The JVM will start with the specified heap size, garbage collection logs will be generated, and thread stack size will be adjusted.
Profiling and performance benchmarking tools allow you to identify performance bottlenecks in your code. These tools help you analyze CPU usage, memory consumption, and execution time of various code segments.
# Use JProfiler for profiling java -agentpath:/path/to/jprofiler/bin/jprofilerti.jar=port=8849 -jar MyApp.jar
# Benchmarking using JMH (Java Microbenchmarking Harness) @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MILLISECONDS) public class BenchmarkExample {
@Benchmark
public void testMethod() {
// Method to benchmark
}
}
Output: JProfiler will start profiling the application, and JMH will measure the execution time of the benchmarked method.
Reactive Programming is a programming paradigm focused on handling asynchronous data streams and the propagation of changes. It is based on the Observer pattern where data streams (or events) are observed, and changes are propagated automatically. It allows systems to be more responsive, resilient, and elastic. Reactive systems are designed to handle a large number of events in real time, making them ideal for scenarios with large-scale or high-concurrency applications.
import reactor.core.publisher.Flux;
public class Main {
public static void main(String[] args) {
Fluxflux = Flux.just("A", "B", "C", "D");
flux.subscribe(item -> System.out.println("Received: " + item));
}
}
Output:
Received: A
Received: B
Received: C
Received: D
Project Reactor is a fully non-blocking reactive programming foundation for the JVM, which is part of the Spring Framework. It provides a robust API to work with asynchronous sequences of data, making it easier to build reactive applications. Reactor includes two main types: Mono (representing 0 or 1 item) and Flux (representing 0 to N items). It allows complex reactive pipelines to be constructed with operations such as map, filter, merge, etc.
import reactor.core.publisher.Flux;
public class Main {
public static void main(String[] args) {
Fluxflux = Flux.just(1, 2, 3, 4);
flux.map(n -> n * 2)
.subscribe(item -> System.out.println("Processed: " + item));
}
}
Output:
Processed: 2
Processed: 4
Processed: 6
Processed: 8
Mono and Flux are the two key components of Project Reactor. Mono represents a sequence of 0 or 1 item, while Flux represents a sequence of 0 to N items. These are the primary building blocks for creating reactive applications in Java. You can combine them in various ways to create complex, reactive pipelines.
import reactor.core.publisher.Mono;
public class Main {
public static void main(String[] args) {
Monomono = Mono.just("Hello, Reactive!");
mono.subscribe(message -> System.out.println(message));
}
}
Output:
Hello, Reactive!
import reactor.core.publisher.Flux;
public class Main {
public static void main(String[] args) {
Fluxflux = Flux.range(1, 5);
flux.subscribe(item -> System.out.println("Item: " + item));
}
}
Output:
Item: 1
Item: 2
Item: 3
Item: 4
Item: 5
Backpressure is a mechanism that helps to deal with overwhelming data in reactive programming. It is important when the consumer is not able to process the data as fast as it is being produced. The reactive streams API introduced in Java 9 includes support for backpressure, allowing for controlled handling of large streams of data. Backpressure helps avoid resource exhaustion, such as memory overload, and ensures that the system remains responsive under load.
import reactor.core.publisher.Flux;
public class Main {
public static void main(String[] args) {
Fluxflux = Flux.range(1, 100);
flux.onBackpressureBuffer()
.subscribe(item -> System.out.println("Item: " + item));
}
}
Output:
Item: 1
Item: 2
Item: 3
...
Item: 100
Building reactive APIs in Java is made easier using Spring WebFlux, a framework built on top of Project Reactor. With WebFlux, you can build APIs that handle asynchronous, non-blocking HTTP requests and responses. This makes your API capable of handling large numbers of requests with low latency.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;
@SpringBootApplication
public class ReactiveApiApplication {
public static void main(String[] args) {
SpringApplication.run(ReactiveApiApplication.class, args);
}
}
@RestController
class HelloController {
@GetMapping("/hello")
public MonosayHello() {
return Mono.just("Hello, Reactive World!");
}
}
Output:
Response: Hello, Reactive World!
Microservices architecture is a design approach that breaks down an application into smaller, independent services that communicate with each other. This architecture is highly scalable, flexible, and allows for better fault isolation.
# Simple Microservice with Spring Boot Example
import org.springframework.boot.SpringApplication; // Import Spring Boot packages
import org.springframework.boot.autoconfigure.SpringBootApplication; // Import Spring Boot annotation
@SpringBootApplication // Marks the main class as the entry point of the Spring Boot application
public class Application { // Main class
public static void main(String[] args) { // Main method
SpringApplication.run(Application.class, args); // Run the Spring Boot application
}
}
# Output: Starts the Spring Boot application with an embedded Tomcat server.
Spring Boot simplifies the process of building microservices by providing a production-ready, embedded server, with built-in support for RESTful APIs and configuration management.
# Spring Boot RESTful Service Example
import org.springframework.boot.SpringApplication; // Import Spring Boot packages
import org.springframework.boot.autoconfigure.SpringBootApplication; // Import Spring Boot annotation
import org.springframework.web.bind.annotation.GetMapping; // Import GetMapping for REST endpoints
import org.springframework.web.bind.annotation.RestController; // Import RestController annotation
@SpringBootApplication // Marks the main class as the entry point
@RestController // Marks the class as a REST controller
public class Application { // Main class
@GetMapping("/hello") // REST endpoint at "/hello"
public String hello() { // Method to handle the GET request
return "Hello, Microservices!"; // Return a simple greeting
}
public static void main(String[] args) { // Main method
SpringApplication.run(Application.class, args); // Run the Spring Boot application
}
}
# Output: A RESTful service that returns "Hello, Microservices!" when accessed at "/hello".
Service discovery allows microservices to automatically detect each other on the network. Eureka, a service discovery server, helps to register and discover services dynamically in a microservices architecture.
# Eureka Server Setup in Spring Boot
import org.springframework.boot.SpringApplication; // Import Spring Boot packages
import org.springframework.boot.autoconfigure.SpringBootApplication; // Import Spring Boot annotation
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer; // Enable Eureka Server
@SpringBootApplication // Marks the main class as the entry point
@EnableEurekaServer // Enable Eureka Server to handle service discovery
public class EurekaServer { // Eureka Server class
public static void main(String[] args) { // Main method
SpringApplication.run(EurekaServer.class, args); // Start Eureka server
}
}
# Output: Eureka Server is up and running, ready for microservices to register.
Load balancing is essential for ensuring high availability and distributing traffic efficiently across instances. Ribbon and Spring Cloud LoadBalancer offer client-side load balancing to manage service instances.
# Load Balancing with Spring Cloud LoadBalancer Example
import org.springframework.beans.factory.annotation.Value; // Import annotation for configuration
import org.springframework.boot.web.client.RestTemplateBuilder; // Import RestTemplate
import org.springframework.cloud.client.loadbalancer.LoadBalanced; // Import LoadBalanced annotation
import org.springframework.context.annotation.Bean; // Import Bean annotation
import org.springframework.context.annotation.Configuration; // Import Configuration annotation
import org.springframework.web.client.RestTemplate; // Import RestTemplate
@Configuration // Configuration class to define beans
public class LoadBalancerConfig { // LoadBalancerConfig class
@Bean // Create RestTemplate bean with load balancing
@LoadBalanced // Enable load balancing
public RestTemplate restTemplate(RestTemplateBuilder builder) { // RestTemplate bean method
return builder.build(); // Return a RestTemplate instance with load balancing
}
}
# Output: The RestTemplate instance is now capable of client-side load balancing.
Hystrix is a library from Netflix that helps to make microservices resilient by implementing circuit breakers, which prevent cascading failures when a service is down or under heavy load.
# Hystrix Circuit Breaker Example
import com.netflix.hystrix.HystrixCommand; // Import HystrixCommand class
import com.netflix.hystrix.HystrixCommandGroupKey; // Import Hystrix group key
public class ResilientServiceCommand extends HystrixCommand{ // Extend HystrixCommand to create resilient service command
public ResilientServiceCommand() { // Constructor
super(HystrixCommandGroupKey.Factory.asKey("ResilientServiceGroup")); // Set group key for Hystrix command
}
@Override // Override the run() method to define the main logic
protected String run() throws Exception { // Run method that gets executed when the command is successful
return "Service Response"; // Simulate successful service response
}
@Override // Override the fallback() method to define the fallback logic
protected String getFallback() { // Fallback method when the service fails
return "Fallback Response"; // Return a fallback response
}
}
# Output: If the main service fails, the circuit breaker will return the fallback response "Fallback Response".
Spring Core is the foundation of the Spring Framework. Dependency Injection (DI) is a design pattern used by Spring to inject dependencies into classes. It reduces coupling between classes and makes code easier to manage and test.
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class GreetingService {
private String message;
public void setMessage(String message) {
this.message = message;
}
public void greet() {
System.out.println(message);
}
}
public class App {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
GreetingService greetingService = (GreetingService) context.getBean("greetingService");
greetingService.greet();
}
}
Output:
Hello from Spring!
Spring MVC is a model-view-controller framework that is part of the Spring Framework. It helps in building web applications. REST controllers in Spring are used to build RESTful web services that handle HTTP requests.
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api")
public class GreetingController {
@GetMapping("/greet")
public String greet() {
return "Hello from Spring MVC!";
}
}
Output:
When accessing the URL "/api/greet", the server will return "Hello from Spring MVC!"
Spring Data JPA is a part of Spring Framework used to integrate the JPA (Java Persistence API) with Spring applications. It simplifies database operations by providing easy-to-use CRUD methods.