This repository contains all java easy, intermediate, hard programs and other concepts.
Here's a detailed technical overview of Java, covering key concepts such as interfaces, streams, and more, along with essential points to remember for interviews and quick reference.
- Java is object-oriented and platform-independent.
- It supports automatic garbage collection.
- Java programs are compiled into bytecode, which is executed by the Java Virtual Machine (JVM).
- Java does not support multiple inheritance with classes but allows it through interfaces.
- Exception handling is an important part of Java to manage errors and exceptions gracefully.
- Java has strong memory management features and provides multithreading capabilities for concurrent programming.
A typical Java program consists of one or more classes. Each class contains methods, and one of these methods is the main
method, which is the entry point of the program.
public class MyClass {
public static void main(String[] args) {
// Code goes here
}
}
Java supports various data types, including primitive types and reference types.
-
Primitive Data Types:
int age = 25; double salary = 50000.0; char grade = 'A'; boolean isEmployed = true;
-
Reference Data Types:
String name = "John Doe"; int[] numbers = {1, 2, 3, 4, 5}; MyClass obj = new MyClass();
Variables must be declared before they are used.
int number; // Declaration
number = 10; // Initialization
Java includes standard control flow statements for decision making and loops.
-
Conditional Statements:
if (condition) { // code } else if (condition) { // code } else { // code } switch (expression) { case value1: // code break; case value2: // code break; default: // code }
-
Looping Statements:
// For loop for (int i = 0; i < 10; i++) { // code } // While loop int i = 0; while (i < 10) { // code i++; } // Do-While loop int i = 0; do { // code i++; } while (i < 10);
Methods are blocks of code that perform a specific task. They can return a value or be void (return nothing).
public class MyClass {
// Method with a return value
public int add(int a, int b) {
return a + b;
}
// Method without a return value
public void printMessage() {
System.out.println("Hello, World!");
}
}
A class is a blueprint for creating objects. An object is an instance of a class.
public class Car {
// Fields
String color;
String model;
// Constructor
public Car(String color, String model) {
this.color = color;
this.model = model;
}
// Method
public void displayInfo() {
System.out.println("Model: " + model + ", Color: " + color);
}
}
// Creating an object
Car myCar = new Car("Red", "Toyota");
myCar.displayInfo();
Inheritance allows one class to inherit fields and methods from another class.
public class Animal {
public void eat() {
System.out.println("Eating...");
}
}
public class Dog extends Animal {
public void bark() {
System.out.println("Barking...");
}
}
// Usage
Dog myDog = new Dog();
myDog.eat(); // Inherited method
myDog.bark(); // Own method
Interfaces define methods that must be implemented by classes.
public interface Animal {
void makeSound();
}
public class Dog implements Animal {
@Override
public void makeSound() {
System.out.println("Bark");
}
}
Java uses try-catch blocks to handle exceptions.
try {
int division = 10 / 0; // This will throw an exception
} catch (ArithmeticException e) {
System.out.println("Cannot divide by zero!");
} finally {
System.out.println("This will always be executed.");
}
Packages are used to group related classes and interfaces.
package com.example;
public class Example {
public void display() {
System.out.println("Hello from Example class!");
}
}
- Java Virtual Machine (JVM): Executes Java bytecode and provides platform independence.
- Java Development Kit (JDK): Includes tools for Java development, such as the compiler (
javac
), debugger, and JVM. - Java Runtime Environment (JRE): Provides the JVM and standard libraries for running Java applications.
- Compiled: Java code is first compiled into bytecode (
.class
files) by the Java Compiler (javac
). This bytecode is platform-independent. - Interpreted: The Java Virtual Machine (JVM) interprets and executes the bytecode on any platform. This allows Java to be platform-independent, following the "write once, run anywhere" principle.
- Encapsulation: Bundling of data (attributes) and methods (functions) into a single unit, known as a class, and restricting access to some of the object's components.
- Inheritance: Java supports single inheritance, where a class can inherit from only one superclass. Multiple inheritance (inheriting from multiple classes) is not supported directly but can be achieved through interfaces.
- Polymorphism: Allows objects to be treated as instances of their parent class rather than their actual class. Method overriding and overloading are examples.
- Abstraction: The concept of hiding the complex implementation details and showing only the necessary features of an object.
- Class: A blueprint for creating objects. Defines a datatype by bundling data and methods.
- Object: An instance of a class, representing a specific implementation of the class with concrete values.
- Interfaces: Java supports multiple inheritance through interfaces. A class can implement multiple interfaces, allowing it to inherit abstract methods from multiple sources.
- Abstract Classes: Cannot be instantiated and can contain abstract methods (methods without implementation) as well as concrete methods (methods with implementation). Used to provide a common base for subclasses.
- Garbage Collection: Java has automatic garbage collection to manage memory, which reclaims memory used by objects that are no longer referenced by the program.
- Exception Handling: Java provides a robust mechanism for handling exceptions using
try
,catch
,finally
,throw
, andthrows
keywords. This helps in managing errors gracefully and maintaining program flow. -
- Try-Catch-Finally: Handles exceptions and ensures resources are released.
- Try Block: Contains code that might throw an exception.
- Catch Block: Handles specific exceptions.
- Finally Block: Executes code regardless of whether an exception occurred.
- Checked vs Unchecked Exceptions:
- Checked Exceptions: Must be handled or declared (
IOException
,SQLException
). - Unchecked Exceptions: Runtime exceptions that do not need to be declared or handled (
NullPointerException
,ArrayIndexOutOfBoundsException
).
- Checked Exceptions: Must be handled or declared (
- Multithreading: Java supports multithreading, allowing multiple threads to run concurrently. The
Thread
class andRunnable
interface are used to create and manage threads. - Synchronization: Java provides synchronization mechanisms to prevent concurrent access issues, using
synchronized
blocks or methods. -
- Threads: Java supports multithreading using
Thread
class andRunnable
interface.
- Threads: Java supports multithreading using
- Synchronization: Ensures thread safety by synchronizing access to shared resources.
- Concurrency Utilities: Java provides utilities like
ExecutorService
,Future
,CountDownLatch
, andSemaphore
for managing concurrency.
- Java Bytecode: Java programs are compiled into platform-independent bytecode, which is executed by the JVM on any platform, ensuring portability.
- Java Standard Library: Includes a wide range of built-in libraries and APIs for tasks like data manipulation, networking, file handling, and GUI development (e.g.,
java.util
,java.io
,java.net
,javax.swing
).
- JVM: Executes Java bytecode and provides an environment for Java programs to run. It handles memory management, garbage collection, and security.
- JDK: A development kit that includes the JRE along with tools for developing Java applications, such as the compiler (
javac
), debugger (jdb
), and other development tools. - JRE: Provides the runtime environment needed to run Java applications, including the JVM and standard libraries.
- Access Modifiers:
public
,protected
, andprivate
control access to classes, methods, and variables. - Other Modifiers:
static
,final
,abstract
,synchronized
,volatile
,transient
, etc., each providing specific functionalities and constraints.
Access modifiers define the visibility of classes, methods, and variables.
- public: Accessible from any other class.
- protected: Accessible within the same package and subclasses.
- default (no modifier): Accessible only within the same package.
- private: Accessible only within the same class.
- Interfaces:
List
,Set
,Map
– Provide abstract data structures. - Implementations:
ArrayList
,HashSet
,HashMap
– Concrete classes implementing these interfaces. - Common Methods:
add()
,remove()
,contains()
,size()
,clear()
,iterator()
.
- Definition: The Streams API allows functional-style operations on sequences of elements, such as collections and arrays.
- Key Operations:
- Intermediate Operations:
filter()
,map()
,sorted()
,distinct()
. - Terminal Operations:
collect()
,forEach()
,reduce()
,count()
.
- Intermediate Operations:
- Syntax:
Collection.stream().filter(...).map(...).collect(Collectors.toList())
.
- Heap vs Stack:
- Heap: Stores objects and their references.
- Stack: Stores method calls and local variables.
- Garbage Collection: Automatically reclaims memory used by objects that are no longer reachable.
- Common Patterns:
- Singleton: Ensures a class has only one instance and provides a global point of access.
- Factory Method: Creates objects without specifying the exact class of object to be created.
- Observer: Allows objects to notify other objects about changes in their state.
- Definition: Apache Tomcat is an open-source web server and servlet container that implements Java Servlet, JavaServer Pages (JSP), and Java Expression Language (EL) specifications.
- Purpose: It is used to run Java web applications by providing a runtime environment for servlets and JSPs.
- Features:
- Servlet Container: Manages the lifecycle of servlets, processes requests, and sends responses.
- JSP Engine: Translates JSPs into servlets and compiles them.
- Web Management Interface: Provides a web-based interface for managing and monitoring Tomcat.
- Support for Java EE: Supports Java EE specifications like Servlet API and JSP API.
- Configuration: Configuration files include
server.xml
,web.xml
, andcontext.xml
which control server settings, application deployment, and context configurations.
- Definition: Java Servlets are server-side programs written in Java that handle client requests and generate dynamic web content, typically used to extend the capabilities of web servers.
- Lifecycle:
- Initialization: The servlet is loaded into memory and initialized using the
init()
method. - Request Handling: The servlet handles requests through the
service()
method, where it processes client requests and generates responses. - Destruction: When the servlet is no longer needed, it is destroyed using the
destroy()
method.
- Initialization: The servlet is loaded into memory and initialized using the
- Key Methods:
init()
: Initializes the servlet. Called once when the servlet is loaded.service(HttpServletRequest req, HttpServletResponse resp)
: Processes requests and generates responses.destroy()
: Cleans up resources before the servlet is destroyed.
- Common Use Cases:
- Handling Form Submissions: Processing form data submitted by users.
- Session Management: Tracking user sessions and maintaining user state.
- Database Interaction: Connecting to databases and performing CRUD operations.
- Deployment Descriptor: The
web.xml
file in theWEB-INF
directory defines servlet configurations, mappings, and initialization parameters.