1.
static Keyword
The static keyword is used to declare class-level variables or methods that belong to the class
itself, rather than to any specific instance of the class. This means:
Static Variables: They are shared among all instances of a class. They are initialized
only once when the class is loaded.
Static Methods: They can be called without creating an instance of the class. They can
only access static variables and methods, not instance-specific members (non-static).
2. final Keyword
The final keyword is used to define constants, prevent method overriding, and prevent
inheritance:
Final Variable: Once assigned, it cannot be modified.
Final Method: It cannot be overridden by subclasses.
Final Class: It cannot be subclassed (i.e., no inheritance).
3. this Keyword
The this keyword refers to the current instance of a class. It is commonly used:
To differentiate between instance variables and parameters that have the same name.
To call the current class's methods or constructors.
4. super Keyword
The super keyword is used to refer to the superclass (parent class) of the current object. It serves
various purposes:
Access Superclass Members: It can be used to call methods or access variables from the
parent class.
Calling Superclass Constructor: It is used to invoke the constructor of the superclass.
static: Defines class-level members.
final: Defines constants, prevents method overriding, and prevents inheritance.
this: Refers to the current object.
super: Refers to the superclass, used to call superclass methods and constructors.
In Java, a constructor is a special method used to initialize objects when they are created. A constructor
is called automatically when an object of a class is created. It has the same name as the class and does
not have a return type .
STRING
String objects are immutable.
Any modification creates a new object.
Suitable for use cases where the string value does not change frequently.
STRING BUFFER
StringBuffer objects are mutable.
Modifications are done in place, making it more efficient for frequent changes.
Suitable for use cases that involve frequent modification of the string.
DATA TYPES AND VARIABLES IN JAVA
Method Overloading in Java
Definition:
Method overloading in Java occurs when you define multiple methods with the same name but
with different parameter lists (either different number of parameters or different types of
parameters)..
Key Points:
Method overloading happens within the same class.
The return type does not play a role in overloading.
It's a form of compile-time polymorphism (or static polymorphism).
Method Overriding in Java
Definition:
Method overriding in Java occurs when a subclass provides its own implementation of a method that is
already defined in its parent class..
Key Points:
It happens between a superclass and a subclass.
The method in the subclass must have the same name, return type, and parameter list as the
method in the superclass.
Runtime polymorphism (dynamic method dispatch) happens through method overriding.
The @Override annotation is used to explicitly indicate method overriding (though not
mandatory, it helps avoid errors).
1. Package in Java
Definition:
A package is a namespace or a container in Java that groups related classes and interfaces together. It
helps in organizing files, preventing naming conflicts, and controlling access to classes.
Types of Packages:
1. Built-in Packages: These are packages that come with the Java standard library (e.g.,
java.util, java.io, java.lang).
2. User-defined Packages: These are custom packages created by the programmer to organize the
classes they write.
Why use packages?
Name conflict management: Packages help avoid naming conflicts by grouping related classes
under a common namespace.
Access protection: You can control the visibility of classes, methods, and variables using access
modifiers (like private, protected, public).
Code organization: Packages help keep the project organized and manageable.
2. Interface in Java
Definition:
An interface in Java is a reference type, similar to a class, that can contain only abstract methods
(methods without a body) and constants (static final variables). Interfaces are used to represent a
contract or a blueprint that a class must follow.
Abstract Methods: Methods without a body, which need to be implemented by the class that
implements the interface.
Constants: Variables that are public, static, and final.
Why use interfaces?
To achieve abstraction: Interfaces allow defining abstract behaviors that classes must
implement.
To support multiple inheritance: Java doesn't support multiple inheritance of classes, but a class
can implement multiple interfaces, allowing for a form of multiple inheritance.
Loose coupling: Interfaces allow objects to communicate with each other without tightly
coupling their implementations.
Exception Handling in Java
Exception handling in Java is a powerful mechanism to handle runtime errors, maintaining the
normal flow of the application. Java provides a robust way to deal with errors through the use of
exception classes, try-catch blocks, and other constructs. This allows the programmer to define
custom behavior for different kinds of errors that might occur during the execution of the
program.
1. What is an Exception?
An exception is an event that disrupts the normal flow of the program. It could be caused by
various issues, such as invalid user input, file not found, division by zero, etc. Exceptions are
objects in Java that represent errors or other exceptional conditions.
Checked Exceptions: Exceptions that are checked at compile time. These must either be
caught or declared in the method signature. E.g., IOException, SQLException.
Unchecked Exceptions: Exceptions that are not checked at compile time. These are
usually programming bugs (e.g., NullPointerException,
ArrayIndexOutOfBoundsException).
Errors: These are critical issues (e.g., OutOfMemoryError) and are usually not handled
in the code. Errors extend Throwable, but you don't typically catch them.
2. Exception Hierarchy in Java
The exception class hierarchy in Java extends from Throwable, which has two main branches:
Error: Represents severe system problems, typically beyond the control of the
application.
Exception: Represents application-specific errors that can be caught and handled by the
program.
text
Copy
Throwable
├── Error
└── Exception
├── RuntimeException (Unchecked exceptions)
└── IOException (Checked exceptions)
3. Exception Handling Keywords in Java
Java provides several keywords to handle exceptions:
try: Defines a block of code that might throw an exception.
catch: Used to handle exceptions that are thrown within a try block.
finally: Defines a block of code that will execute after the try-catch block, regardless
of whether an exception is thrown or not.
throw: Used to explicitly throw an exception.
throws: Used to declare that a method might throw an exception, allowing it to be
handled by the calling method.
Abstract Method in Java
An abstract method is a method that is declared without an implementation. It only has the method
signature, and the actual implementation is provided by subclasses.
Key Points about Abstract Methods:
An abstract method does not have a body (implementation).
It is declared using the abstract keyword.
An abstract class is a class that cannot be instantiated directly. It can have both abstract methods
(methods without implementation) and concrete methods (methods with implementation).
Key Points about Abstract Classes:
An abstract class cannot be instantiated directly (i.e., you cannot create an object of an abstract
class).
It can have both abstract and concrete methods.
An abstract class can have instance variables, constructors, and static methods.
If a class has at least one abstract method, the class itself must be declared abstract.
Basic Concepts of Multithreading
1. Thread: A thread is the smallest unit of execution in a program. In Java, every program
has at least one thread (the main thread).
2. Multithreading: It is the concurrent execution of more than one thread. A thread runs
independently, allowing multiple tasks to be performed at once.
3. Process: A process is a program that is running, and it can have multiple threads running
in it. All threads in a process share the same memory space but have their own execution
path.
Creating Threads in Java
In Java, there are two main ways to create threads:
1. By Extending the Thread class
2. By Implementing the Runnable interface
Synchronization ensures that only one thread can access a shared resource at a time,
preventing data corruption or inconsistency.
Deadlock occurs when two or more threads are blocked forever, each waiting for the
other to release a resource, causing the program to halt or freeze.
AWT (Abstract Window Toolkit) is a set of APIs used for building graphical user interfaces
(GUIs) in Java. It provides a wide range of controls or components like buttons, text fields,
checkboxes, labels, etc., that can be added to your application. These components are the
building blocks for developing interactive user interfaces.
Java AWT controls are platform-independent, and they are part of the java.awt package. They
provide various interactive elements that allow users to interact with the application.
Event Handling Basics
In Java, event handling follows the event-driven programming model. This means that an
application is driven by user interactions, such as clicks, key presses, or mouse movements.
Basic Workflow of Event Handling
1. Source: The object that generates an event (e.g., a button, a text field).
2. Event: The actual action that occurs (e.g., a button click).
3. Listener: An interface that receives and processes the event.
4. Event-Handling Mechanism: The mechanism by which the event listener is registered
with the source so that the program can respond to the event.
Types of Events in Java
There are several types of events in Java:
ActionEvent: Generated when a button or menu item is clicked.
MouseEvent: Generated when the mouse is clicked, moved, dragged, or released.
KeyEvent: Generated when a key is pressed or released.
WindowEvent: Generated when a window is opened, closed, or activated.
FocusEvent: Generated when a component gains or loses focus
Basic Definition
AWT (Abstract Window Toolkit):
o AWT is Java’s original platform-dependent GUI toolkit.
o It is part of Java’s standard library and provides components like buttons, text
fields, labels, and other basic user interface elements.
o AWT components are platform-dependent, which means they rely on the native
GUI of the operating system.
Swing:
o Swing is a more advanced and powerful GUI toolkit that was developed as an
extension of AWT.
o It is a part of Java’s standard library and provides a rich set of GUI components
like buttons, tables, trees, lists, text areas, etc.
o Swing components are platform-independent because they are written entirely in
Java. They do not rely on the native GUI of the operating system, making them
more consistent across different platforms.
