Prepared By: Prof. Uday Shah (HOD - IT)
Ruparel Education Pvt. Ltd.
BCA2202: OOP using JAVA
UNIT 1: Introduction to Java &
OOP Concepts
1. Introduction to Java
Java is a high-level, object-oriented
programming language developed by Sun Microsystems. It is widely used for
building desktop applications, web applications, and mobile applications.
Java is designed to be simple,
secure, and portable. One of its most important features is “Write Once, Run
Anywhere”, which means Java programs can run on any system without
modification.
Java uses a virtual machine called
JVM (Java Virtual Machine) to execute programs. This allows platform
independence and makes Java very powerful.
It also supports object-oriented
programming concepts such as classes, objects, inheritance, and polymorphism.
Due to its reliability and
performance, Java is widely used in industries such as banking, enterprise
applications, and Android development.
2. Java Buzzwords (Features of Java)
Java has several important features,
also known as Java buzzwords. These features make Java a popular programming
language.
Java is simple and easy to learn
because it removes complex features like pointers. It is also object-oriented,
which helps in organizing code using classes and objects.
Java is platform-independent, meaning
programs can run on any system with JVM support.
It is secure because it does not
allow direct memory access and includes built-in security features.
Java is also multithreaded and
supports distributed computing, making it suitable for large-scale
applications.
3. JVM, JRE, and JDK
Java uses three main components: JVM,
JRE, and JDK.
The JVM (Java Virtual Machine)
is responsible for executing Java programs. It converts bytecode into machine
code.
The JRE (Java Runtime Environment)
provides libraries and runtime support needed to run Java programs.
The JDK (Java Development Kit)
is a complete package that includes tools for developing Java applications.
These components work together to
compile and execute Java programs.
Understanding these components is
important for Java development.
4. Structure of Java Program
A Java program follows a specific
structure. It includes class definition, main method, and statements.
Every Java program must have at least
one class and one main method, which acts as the entry point.
The main method is where the
execution of the program begins.
Java programs are written using a
specific syntax that must be followed strictly.
Understanding program structure helps
in writing correct and efficient Java programs.
5. Data Types in Java
Data types define the type of data
that a variable can store. Java supports different data types such as integers,
floating-point numbers, characters, and boolean.
There are two main types of data
types: primitive and non-primitive.
Primitive data types include int,
float, char, and boolean.
Non-primitive data types include
arrays, classes, and objects.
Proper use of data types helps in
efficient memory usage and program execution.
6. Control Statements (Decision
Making & Looping)
Control statements are used to
control the flow of a program.
Decision-making statements such as
if, if-else, and switch allow the program to take decisions.
Looping statements such as for,
while, and do-while are used to repeat a block of code.
Jumping statements such as break and
continue are used to control loops.
Control statements are essential for
creating logical and dynamic programs.
7. Arrays in Java
Arrays are used to store multiple
values of the same type in a single variable.
Java supports one-dimensional,
two-dimensional, and multi-dimensional arrays.
Arrays are useful for storing large
amounts of data efficiently.
They provide easy access to elements
using index values.
Arrays are widely used in
applications like data processing and storage.
8. Class and Object
A class is a blueprint for creating
objects. It defines properties and methods.
An object is an instance of a class.
It represents real-world entities.
Classes and objects are the
foundation of object-oriented programming.
They help in organizing code and
improving reusability.
Using classes and objects makes
programs more structured and manageable.
9. Encapsulation
Encapsulation is the process of
wrapping data and methods into a single unit called a class.
It protects data from unauthorized
access by using access modifiers.
Encapsulation improves data security
and code maintainability.
It allows controlled access to data
through methods.
This concept is widely used in
real-world applications.
10. Inheritance and Polymorphism
Inheritance allows one class to
acquire properties and methods of another class. It promotes code reusability.
Polymorphism allows one method to
perform different tasks based on the situation.
Inheritance reduces code duplication
and improves structure.
Polymorphism increases flexibility
and efficiency in programs.
These concepts are essential for
object-oriented programming.
UNIT 2: Java Class, Constructor &
Inheritance
1. Class Fundamentals
A class is the basic building block
of object-oriented programming in Java. It is like a blueprint or template used
to create objects. A class defines properties (variables) and behaviors
(methods) of an object.
Classes help in organizing code in a
structured way. Instead of writing everything in a single program, developers
can divide the program into multiple classes.
Each class can represent a real-world
entity such as Student, Employee, or Car. This makes programming more
meaningful and easier to understand.
Classes support modular programming,
which improves code readability and reusability.
Understanding classes is very
important because all Java programs are based on classes.
2. Object Creation and Class Members
An object is an instance of a class.
It represents a real-world entity and contains actual values of properties
defined in the class.
Class members include variables and
methods. Variables store data, while methods define actions that objects can
perform.
Objects are created from classes and
used to access class members. Each object has its own copy of variables.
Objects help in implementing
real-world concepts in programming.
They improve flexibility and allow
multiple instances of the same class.
3. Static and Non-Static Members
In Java, class members can be static
or non-static.
Static members belong to the class itself and are
shared among all objects. They are created only once.
Non-static members belong to individual objects, and
each object has its own copy.
Static members are useful when a
value is common for all objects, such as a company name.
Non-static members are used when
values differ for each object, such as student name or age.
Understanding static and non-static
members helps in efficient memory usage.
4. Constructors in Java
A constructor is a special method
used to initialize objects. It is automatically called when an object is
created.
Constructors help in assigning
initial values to variables.
There are different types of
constructors such as default constructor and parameterized constructor.
Constructors make object creation
easy and ensure proper initialization.
They are important for setting up
objects correctly before use.
5. Constructor Overloading
Constructor overloading means having
multiple constructors in a class with different parameters.
It allows objects to be created in
different ways based on requirements.
Each constructor performs a different
initialization task.
This improves flexibility and makes
the program more versatile.
Constructor overloading is an example
of polymorphism in Java.
6. Access Specifiers (Public,
Private, Protected, Default)
Access specifiers are used to control
access to class members.
Public members are accessible from
anywhere.
Private members are accessible only within the class.
Protected members are accessible within the package and subclasses.
Default access is limited to the same package.
Access specifiers improve security
and protect data.
They help in implementing
encapsulation.
Proper use of access specifiers
ensures safe and controlled access to data.
7. Garbage Collection
Garbage collection is the process of
automatically deleting unused objects from memory.
Java handles memory management
automatically, which reduces the burden on developers.
When an object is no longer needed,
the garbage collector removes it.
This prevents memory leaks and
improves performance.
Garbage collection is an important
feature of Java that ensures efficient memory usage.
8. Abstract Class and Final Keyword
An abstract class is a class that
cannot be instantiated and may contain abstract methods.
Abstract methods do not have a body
and must be implemented by subclasses.
The final keyword is used to
restrict modification. A final class cannot be inherited, and a final method
cannot be overridden.
Abstract classes help in achieving
abstraction, while final keyword ensures security.
These concepts improve code structure
and reliability.
9. Inheritance in Java
Inheritance is a concept where one
class acquires properties and methods of another class.
It promotes code reuse and reduces
duplication.
There are different types of
inheritance such as single, multilevel, and hierarchical inheritance.
Inheritance helps in building
relationships between classes.
It is one of the most important
concepts in object-oriented programming.
10. Method Overriding and super
Keyword
Method overriding occurs when a
subclass provides a specific implementation of a method defined in the parent
class.
It allows runtime polymorphism and
improves flexibility.
The super keyword is used to
access parent class methods and constructors.
It helps in reusing parent class
functionality.
Method overriding and super keyword
are important for implementing inheritance effectively.
UNIT 3: Interface, Package & Java
API
1. Introduction to Interface
An interface in Java is a special
type of class that contains only abstract methods. It is used to achieve
abstraction and multiple inheritance.
Interfaces define what a class should
do, but not how it should do it. This helps in separating logic from
implementation.
A class that implements an interface
must provide implementation for all its methods.
Interfaces are useful when different
classes need to follow the same structure but perform tasks differently.
They improve flexibility and help in
designing scalable applications.
2. Implementing Interfaces
When a class implements an interface,
it must define all the methods declared in the interface.
This ensures that the class follows a
specific structure defined by the interface.
A single class can implement multiple
interfaces, which allows multiple inheritance in Java.
Implementing interfaces improves code
reusability and consistency.
It also helps in maintaining a clear
structure in large applications.
3. Variables and Methods in Interface
In an interface, variables are by
default public, static, and final. This means they are constant values.
Methods in interfaces are abstract by
default, meaning they do not have a body.
These methods must be implemented by
the class that uses the interface.
Interfaces provide a contract that
ensures all implementing classes follow the same rules.
This makes code more organized and
predictable.
4. Polymorphism using Interface
Interfaces support polymorphism by
allowing different classes to implement the same interface in different ways.
This means a single interface can be
used to represent multiple types of objects.
Polymorphism improves flexibility and
allows dynamic method execution.
It is widely used in real-world
applications to handle multiple behaviors.
Using interfaces for polymorphism
makes code more reusable and efficient.
5. Introduction to Java Packages
A package in Java is a collection of
related classes and interfaces. It helps in organizing code into different
groups.
Packages prevent naming conflicts and
improve code management.
Java provides built-in packages as
well as user-defined packages.
Packages are useful in large projects
where multiple classes are used.
They help in maintaining a structured
and organized codebase.
6. Creating and Using Packages
Developers can create their own
packages to group related classes together.
Packages can be imported into other
programs using import statements.
This allows code reuse and modular
programming.
Packages improve readability and
maintainability of code.
Using packages helps in managing
large applications effectively.
7. Java API Packages
Java provides a large number of
built-in packages called Java API.
These packages contain pre-defined
classes and methods for common tasks.
Some important packages include
java.lang, java.util, java.io, java.net, java.awt, and javax.swing.
These packages provide
functionalities like input/output, networking, GUI development, and utilities.
Using Java API reduces development
time and improves efficiency.
8. Wrapper Classes
Wrapper classes are used to convert
primitive data types into objects.
Each primitive type has a
corresponding wrapper class, such as Integer for int and Double for double.
Wrapper classes are useful when
working with collections and object-based operations.
They provide methods for data
conversion and manipulation.
Wrapper classes improve flexibility
and allow better data handling.
9. String and StringBuffer Classes
String and StringBuffer are classes
used to handle text data in Java.
A String object is immutable, meaning
its value cannot be changed after creation.
StringBuffer is mutable, meaning its
value can be modified.
StringBuffer is more efficient when
frequent changes are required.
Both classes are widely used in Java
applications for text processing.
10. Utility Classes (Random, Date,
Scanner, etc.)
Java provides many utility classes
that simplify programming tasks.
The Random class is used to generate
random numbers.
The Date class is used to handle date
and time operations.
The Scanner class is used to take
input from users.
Other classes like Vector, Hashtable,
and Stack are used for data storage and manipulation.
These utility classes reduce coding
effort and improve program efficiency.
UNIT 4: Exception Handling &
Multithreading
1. Introduction to Exception Handling
Exception handling is a mechanism
used to handle runtime errors in a program. These errors occur during program
execution and can cause the program to crash if not handled properly.
In Java, exceptions are objects that
represent an error condition. Exception handling allows the program to continue
execution even after an error occurs.
The main purpose of exception
handling is to make programs more robust and reliable. It helps in preventing
unexpected crashes.
Exception handling also improves user
experience by displaying proper error messages instead of terminating the
program.
It is an essential feature in Java
for building stable and secure applications.
2. Exception Hierarchy
Java provides a structured hierarchy
of exception classes. All exceptions are derived from the base class called
Throwable.
Throwable is divided into two main
categories: Error and Exception.
Errors represent serious problems
that cannot be handled, such as memory issues.
Exceptions represent problems that
can be handled by the program.
The Exception class is further
divided into checked and unchecked exceptions.
Understanding exception hierarchy
helps in handling different types of errors effectively.
3. try, catch, finally Blocks
The try, catch, and finally blocks
are used to handle exceptions in Java.
The try block contains code that may
produce an exception.
The catch block is used to handle the
exception and provide an alternative solution.
The finally block is always executed,
whether an exception occurs or not. It is used for cleanup tasks.
These blocks ensure that the program
runs smoothly even when errors occur.
4. throw and throws Keyword
The throw keyword is used to manually
generate an exception in a program.
It is useful when a programmer wants
to create a custom error condition.
The throws keyword is used to declare
exceptions that a method may produce.
It informs the caller about possible
exceptions.
Both keywords help in better control
and handling of exceptions.
5. User Defined Exceptions
User-defined exceptions are custom
exceptions created by programmers.
They are used when built-in
exceptions are not sufficient.
Custom exceptions improve code
clarity and provide meaningful error messages.
They help in handling
application-specific errors effectively.
User-defined exceptions are widely
used in real-world applications.
6. Introduction to Multithreading
Multithreading is a process of
executing multiple threads simultaneously within a program.
A thread is a small unit of
execution. It allows programs to perform multiple tasks at the same time.
Multithreading improves performance
and efficiency of applications.
It is commonly used in applications
like games, web servers, and real-time systems.
Multithreading makes programs faster
and more responsive.
7. Thread Class and Runnable
Interface
Java provides two ways to create
threads: using Thread class and Runnable interface.
The Thread class is used to create
and manage threads directly.
The Runnable interface provides a
more flexible way to create threads.
Using Runnable is preferred because
it allows multiple inheritance.
Both methods are used based on
application requirements.
8. Thread Life Cycle
A thread passes through different
states during its execution.
These states include new, runnable,
running, waiting, and terminated.
Each state represents a stage in the
thread’s life.
Understanding the life cycle helps in
managing threads effectively.
It ensures proper execution and
coordination of multiple threads.
9. Daemon and Non-Daemon Threads
Threads are classified into daemon
and non-daemon threads.
Daemon threads run in the background
and support other threads.
Non-daemon threads perform main tasks
and keep the program running.
When all non-daemon threads finish,
daemon threads automatically stop.
Daemon threads are used for
background tasks like garbage collection.
10. Synchronization in Multithreading
Synchronization is used to control
access to shared resources in multithreading.
When multiple threads access the same
resource, conflicts may occur.
Synchronization ensures that only one
thread accesses the resource at a time.
It prevents data inconsistency and
improves reliability.
Synchronization is important for
maintaining data integrity in multithreaded applications.
UNIT 5: GUI Programming & Event
Handling
1. Introduction to GUI Programming
GUI (Graphical User Interface)
programming is used to create applications with visual components like buttons,
text fields, and windows. It allows users to interact with applications easily.
In Java, GUI programming is done
using AWT (Abstract Window Toolkit) and Swing. These libraries provide
ready-made components to build user interfaces.
GUI makes applications more
user-friendly compared to command-line programs. Users can interact using mouse
and keyboard.
GUI programming is widely used in
desktop applications like calculators, forms, and management systems.
Understanding GUI is important for
building interactive and attractive applications.
2. AWT vs Swing
AWT and Swing are two libraries used
for GUI development in Java.
AWT is an older library that uses
native system components. It depends on the operating system for its look and
feel.
Swing is an advanced library built on
top of AWT. It provides lightweight components and is platform-independent.
Swing offers more features and better
customization compared to AWT.
Due to its flexibility and modern
design, Swing is widely used in Java applications.
3. Swing Components
Swing provides many components for
building user interfaces.
Basic components include JLabel,
JButton, JTextField, JTextArea, JCheckBox, and JRadioButton.
These components are used to display
text, take input, and perform actions.
Swing components are flexible and
customizable.
They help in creating interactive and
user-friendly applications.
4. Swing Containers
Containers are components that hold
other components.
Common containers include JFrame and
JPanel.
JFrame is the main window of the
application, while JPanel is used to group components.
Containers help in organizing
components properly.
They provide structure to the user
interface.
5. Layout Managers
Layout managers are used to arrange
components in a container.
Common layout managers include
FlowLayout, BorderLayout, and GridLayout.
FlowLayout arranges components in a
row, BorderLayout divides the container into regions, and GridLayout arranges
components in a grid.
Layout managers help in designing
flexible and responsive interfaces.
They ensure proper alignment and
positioning of components.
6. Graphics in Java
Java provides graphics capabilities
to draw shapes, text, and images.
The Graphics class is used for
drawing operations.
Developers can draw lines,
rectangles, circles, and other shapes.
Graphics are used in applications
like games, charts, and design tools.
Understanding graphics helps in
creating visually rich applications.
7. Event Handling
Event handling is the process of
responding to user actions such as clicks, typing, or mouse movement.
In GUI applications, events are
generated when users interact with components.
Event handling allows the program to
perform actions based on user input.
It makes applications interactive and
dynamic.
Without event handling, GUI
applications would not respond to user actions.
8. Event Delegation Model
Java uses the event delegation model
for handling events.
In this model, an event source
generates an event, and a listener handles it.
Components act as event sources, and
listeners are interfaces that define event-handling methods.
This model separates event generation
from handling.
It improves flexibility and makes
event handling more organized.
9. Event Classes and Listener
Interfaces
Java provides different event classes
such as ActionEvent, MouseEvent, and KeyEvent.
These classes represent different
types of user actions.
Listener interfaces such as
ActionListener, MouseListener, and KeyListener are used to handle events.
Each listener defines methods that
must be implemented.
These concepts are essential for
handling user interactions in GUI applications.
10. Adapter Classes
Adapter classes are used to simplify
event handling.
Instead of implementing all methods
of a listener interface, developers can extend an adapter class and override
only required methods.
This reduces coding effort and
improves readability.
Adapter classes are useful when only
a few methods need to be handled.
They make event handling easier and
more efficient.
