AKTU OOP with Java Question Paper Solutions

BCS403 - Even Semester 2023-24

Section A - Short Answer Questions (20 Marks)

Each question carries 2 marks

A. Define Byte Code (BKL: K1-K2 Level)

Answer: Byte code is an intermediate representation of Java source code that is platform-independent.
When Java source code is compiled using javac compiler, it generates .class files containing byte code. This
byte code is then executed by the Java Virtual Machine (JVM) on any platform, making Java "write once,
run anywhere."

B. What is Object and Class (BKL: K1-K2 Level)

Answer:

 Object: An object is an instance of a class that has state (attributes) and behavior (methods). It
represents a real-world entity in programming.
 Class: A class is a blueprint or template that defines the structure and behavior of objects. It contains
data members and member functions that operate on the data.

C. What do you mean by Exception Handling (BKL: K1-K2 Level)

Answer: Exception handling is a mechanism in Java to handle runtime errors gracefully. It uses try-catch-
finally blocks to catch and handle exceptions, preventing program termination. It helps maintain normal
program flow even when unexpected errors occur.

D. Differentiate between sleep() and start() (BKL: K1-K2 Level)

Answer:

 sleep(): Pauses the execution of current thread for a specified time period. Thread remains in blocked
state and automatically resumes after the time expires.
 start(): Initiates the execution of a thread by calling the run() method. It creates a new thread and
makes it ready to run.

E. Write down any two advantages of Functional Interface (BKL: K1-K2 Level)

Answer:

1. Lambda Expression Support: Functional interfaces enable the use of lambda expressions, making
code more concise and readable.
2. Method References: They allow method references, reducing boilerplate code and improving code
maintainability.

F. What is Inner Anonymous Class (BKL: K1-K2 Level)

Answer: Inner Anonymous Class is a class without a name that is defined and instantiated at the same time.
It's used when we need to create a class that extends another class or implements an interface for one-time
use only, typically for event handling.

G. Write some methods name of Collection interface (BKL: K1-K2 Level)

Answer: add(), remove(), contains(), size(), isEmpty(), clear(), iterator(), toArray()

H. What is Properties class (BKL: K1-K2 Level)

Answer: Properties class is a subclass of Hashtable that stores key-value pairs as strings. It's commonly
used for configuration files, storing application settings, and maintaining property lists that can be loaded
from or saved to files.

I. Define Auto Wiring (BK: K1-K2 Level)

Answer: Auto Wiring is a feature in Spring Framework that automatically injects dependencies into beans
without explicit configuration. Spring container automatically resolves and injects collaborating beans by
matching data types, names, or constructors.

J. Explain Spring boot Logger (BKL: K1-K2 Level)

Answer: Spring Boot Logger is a built-in logging framework that provides different logging levels
(ERROR, WARN, INFO, DEBUG, TRACE). It uses SLF4J as the logging facade and Logback as the
default implementation, allowing developers to log application events and debug information efficiently.

Section B - Long/Medium Answer Questions (30 Marks)

Each question carries 6 marks

Q.2 (CO-1): Explain the role of final, static and private keyword in Java with Suitable
example

Answer:

final keyword:

 Variables: Creates constants that cannot be modified once initialized

 Methods: Prevents method overriding in subclasses
 Classes: Prevents class inheritance

static keyword:

 Belongs to class rather than instance

 Shared among all objects of the class
 Can be accessed without creating object instance
 Static methods can only access static variables and methods

private keyword:

 Provides highest level of access restriction

 Members are accessible only within the same class
  Ensures data encapsulation and security
 Cannot be accessed from outside the class

Example Context: In a BankAccount class, account number could be final (unchangeable), interest rate
could be static (same for all accounts), and balance could be private (accessible only through methods).

Q.3 (CO-2): Illustrate Exception Handling in details with example. Why Exception
Handling is required?

Answer:

Exception Handling Mechanism: Exception handling in Java uses try-catch-finally blocks to manage
runtime errors gracefully.

Components:

1. try block: Contains code that might throw an exception

2. catch block: Handles specific exceptions
3. finally block: Executes regardless of exception occurrence
4. throw keyword: Manually throws exceptions
5. throws keyword: Declares exceptions that method might throw

Exception Hierarchy:

 Throwable (root class)

o Error (system-level errors)
o Exception
 RuntimeException (unchecked)
 Other exceptions (checked)

Why Exception Handling is Required:

1. Program Stability: Prevents abrupt program termination

2. Error Recovery: Allows graceful handling of unexpected situations
3. User Experience: Provides meaningful error messages
4. Resource Management: Ensures proper cleanup of resources
5. Debugging: Helps identify and fix issues in code

Benefits: Separates error handling code from normal business logic, making code more readable and
maintainable.

Q.4 (CO-3): Explain Default method and static method with example

Answer:

Default Methods:

 Introduced in Java 8 for interface evolution

 Provide default implementation in interfaces
 Allow adding new methods to interfaces without breaking existing implementations
 Can be overridden by implementing classes
 Use 'default' keyword

Static Methods in Interfaces:

  Belong to interface, not to implementing class
 Cannot be overridden by implementing classes
 Called using interface name
 Provide utility methods related to interface functionality
 Use 'static' keyword

Key Differences:

1. Inheritance: Default methods are inherited; static methods are not

2. Overriding: Default methods can be overridden; static methods cannot
3. Access: Default methods accessed through object; static methods through interface name

Use Cases:

 Default methods: Backward compatibility when adding new methods to interfaces

 Static methods: Utility functions that don't require object state

Benefits: Enable interface evolution without breaking existing code, provide utility methods, and support
functional programming concepts.

Q.5 (CO-4): Explain Collection Framework with Hierarchy

Answer:

Collection Framework Overview: The Java Collection Framework is a unified architecture for
representing and manipulating collections of objects. It provides interfaces, implementations, and algorithms
to work with groups of objects.

Core Interfaces Hierarchy:

Collection Interface (Root):

 List Interface: Ordered collection allowing duplicates

o ArrayList: Resizable array implementation
o LinkedList: Doubly-linked list implementation
o Vector: Synchronized resizable array
 Set Interface: No duplicate elements allowed
o HashSet: Hash table implementation
o LinkedHashSet: Hash table with insertion order
o TreeSet: Sorted set using Red-Black tree
 Queue Interface: FIFO (First-In-First-Out) collection
o PriorityQueue: Priority-based queue
o ArrayDeque: Resizable array implementation

Map Interface (Separate Hierarchy):

 HashMap: Hash table implementation

 LinkedHashMap: Hash table with insertion/access order
 TreeMap: Sorted map using Red-Black tree
 Hashtable: Synchronized hash table

Key Features:

1. Consistency: Uniform API across different collection types

2. Performance: Optimized implementations for different use cases
 3. Flexibility: Multiple implementations for each interface
4. Interoperability: Collections can work together seamlessly

Section C - Long Answer Questions (50 Marks)

Each question carries 10 marks

Q.7 (CO-1): State the basic features/characteristics of Object-Oriented Programming

(OOP)

Answer:

1. Encapsulation:

 Bundling data and methods that operate on that data within a single unit (class)
 Data hiding through access modifiers (private, protected, public)
 Provides security and integrity to data
 Prevents unauthorized access and modification
 Example: Private variables accessed through public getter/setter methods

2. Inheritance:

 Mechanism where one class acquires properties and behaviors of another class
 Promotes code reusability and establishes IS-A relationship
 Types: Single, Multiple (through interfaces), Multilevel, Hierarchical
 Parent class (superclass) and child class (subclass) relationship
 Uses 'extends' keyword in Java

3. Polymorphism:

 Ability of objects to take multiple forms

 Method overloading (compile-time polymorphism): Same method name with different parameters
 Method overriding (runtime polymorphism): Subclass provides specific implementation
 Enables dynamic method dispatch
 Supports flexibility and extensibility

4. Abstraction:

 Hiding complex implementation details while showing only essential features

 Abstract classes and interfaces provide abstraction
 Focuses on what an object does rather than how it does it
 Reduces complexity and increases efficiency
 Example: Abstract class defining common behavior for subclasses

Additional OOP Principles:

 Association: Relationship between objects

 Aggregation: "Has-A" relationship (weak association)
 Composition: Strong "Has-A" relationship
 Message Passing: Objects communicate through method calls

Benefits of OOP:
  Code reusability and modularity
 Easier maintenance and debugging
 Better organization of code
 Real-world problem modeling
 Scalability and extensibility

Q.8 (CO-2): Write a program in java to implement try with multiple catch

Answer:

Try with Multiple Catch Blocks:

Multiple catch blocks allow handling different types of exceptions that might occur in a try block. Each
catch block handles a specific exception type, providing appropriate error handling for different scenarios.

Structure and Syntax:

try {
// Code that may throw exceptions
} catch (SpecificException1 e) {
// Handle specific exception type 1
} catch (SpecificException2 e) {
// Handle specific exception type 2
} catch (Exception e) {
// Handle any other exception
} finally {
// Optional cleanup code
}

Program Logic Explanation:

1. Try Block: Contains code that might throw various exceptions

2. Multiple Catch Blocks: Each handles specific exception types
3. Exception Hierarchy: More specific exceptions should be caught first
4. Generic Catch: General Exception catch should be last
5. Finally Block: Executes regardless of exception occurrence

Key Points:

 Order of catch blocks matters (specific to general)

 Only one catch block executes per exception
 Each catch block can have different handling logic
 Multiple exceptions can be caught in single catch using pipe (|) operator

Common Exception Types:

 ArithmeticException: Division by zero

 ArrayIndexOutOfBoundsException: Invalid array index
 NullPointerException: Null object reference
 NumberFormatException: Invalid number format
 IOException: Input/output operations

Benefits:

 Specific error handling for different exception types

 Better error reporting and debugging
 Graceful program continuation
  Resource cleanup in finally block

Q.9 (CO-3): Explain concepts of Functional Interface

Answer:

Functional Interface Definition: A functional interface is an interface that contains exactly one abstract
method. It can have multiple default methods, static methods, and methods inherited from Object class, but
only one abstract method. Also known as SAM (Single Abstract Method) interface.

Key Characteristics:

1. Single Abstract Method: Contains exactly one unimplemented method

2. @FunctionalInterface Annotation: Optional but recommended for clarity
3. Lambda Expression Support: Can be implemented using lambda expressions
4. Method References: Support method reference syntax
5. Default Methods Allowed: Can contain multiple default methods

Built-in Functional Interfaces:

1. Predicate<T>:

 Method: boolean test(T t)

 Purpose: Represents a boolean-valued function
 Usage: Filtering operations, conditional checks

2. Function<T,R>:

 Method: R apply(T t)
 Purpose: Represents a function that accepts one argument and produces result
 Usage: Transformation operations, mapping

3. Consumer<T>:

 Method: void accept(T t)

 Purpose: Represents operation that accepts single input argument and returns no result
 Usage: Processing operations, side effects

4. Supplier<T>:

 Method: T get()
 Purpose: Represents supplier of results
 Usage: Factory methods, lazy evaluation

5. UnaryOperator<T>:

 Method: T apply(T t)
 Purpose: Represents operation on single operand producing result of same type
 Usage: Mathematical operations, transformations

Advantages:

 Concise Code: Lambda expressions reduce boilerplate code

 Functional Programming: Enables functional programming paradigms
 Stream API Integration: Works seamlessly with Stream API
  Parallel Processing: Supports parallel operations
 Code Reusability: Promotes higher-order functions

Applications:

 Event handling in GUI applications

 Collection processing with Stream API
 Callback mechanisms
 Strategy pattern implementation
 Functional composition

Q.10 (CO-4): Explain List interface with example

Answer:

List Interface Overview: List is a child interface of Collection that represents an ordered collection
(sequence) of elements. It allows duplicate elements and provides positional access to elements using index-
based operations.

Key Characteristics:

1. Ordered Collection: Maintains insertion order of elements

2. Index-Based Access: Elements can be accessed using integer index (0-based)
3. Duplicate Elements: Allows duplicate values
4. Dynamic Size: Can grow and shrink during runtime
5. Null Elements: Allows null values (implementation dependent)

Important Methods:

 add(index, element): Inserts element at specified position

 get(index): Returns element at specified index
 set(index, element): Replaces element at specified position
 remove(index): Removes element at specified index
 indexOf(element): Returns first occurrence index
 lastIndexOf(element): Returns last occurrence index
 subList(fromIndex, toIndex): Returns portion of list

List Implementations:

1. ArrayList:

 Resizable array implementation

 Fast random access (O(1) for get/set)
 Slower insertion/deletion in middle (O(n))
 Not synchronized (not thread-safe)
 Best for frequent access operations

2. LinkedList:

 Doubly-linked list implementation

 Slower random access (O(n) for get/set)
 Fast insertion/deletion at any position (O(1))
 Implements both List and Deque interfaces
 Best for frequent insertion/deletion operations
3. Vector:

 Similar to ArrayList but synchronized

 Thread-safe but slower performance
 Legacy class from Java 1.0
 Grows by 100% when capacity exceeded

Use Cases:

 ArrayList: When frequent random access is needed

 LinkedList: When frequent insertion/deletion operations
 Vector: When thread safety is required (though Collections.synchronizedList() is preferred)

Performance Comparison:

 Access: ArrayList > Vector > LinkedList

 Insertion/Deletion: LinkedList > ArrayList > Vector
 Memory: ArrayList > LinkedList > Vector

Q.11 (CO-5): Explain the advantage of Spring framework

Answer:

Spring Framework Overview: Spring is a comprehensive, lightweight framework for enterprise Java
development that provides infrastructure support for developing robust Java applications. It addresses most
aspects of enterprise application development and offers a consistent programming model across different
application tiers.

Key Advantages:

1. Inversion of Control (IoC) and Dependency Injection:

 Spring container manages object creation and lifecycle

 Dependencies are injected automatically, reducing tight coupling
 Objects don't need to locate or create their dependencies
 Promotes loose coupling and high cohesion
 Configurable through XML, annotations (@Autowired, @Component), or Java configuration
 Makes applications more testable and maintainable

2. Aspect-Oriented Programming (AOP) Support:

 Separates cross-cutting concerns from core business logic

 Handles system-wide concerns like logging, security, transaction management, caching
 Reduces code duplication and improves modularity
 Supports both proxy-based and AspectJ weaving
 Declarative approach for common enterprise concerns

3. Lightweight and Non-Intrusive:

 Non-invasive framework - doesn't force inheritance from framework classes

 Works with Plain Old Java Objects (POJOs)
 Minimal runtime overhead and memory footprint
 Easy to integrate with existing applications
 No vendor lock-in - applications remain portable
4. Comprehensive Integration Capabilities:

 Seamless integration with popular frameworks (Hibernate, JPA, MyBatis, Struts)

 Database connectivity through JDBC abstraction
 Web services support (REST, SOAP, GraphQL)
 Message queuing integration (JMS, RabbitMQ, Apache Kafka)
 Enterprise Integration Patterns support

5. Declarative Transaction Management:

 Comprehensive transaction support across different transaction APIs

 Declarative transaction management using @Transactional annotation
 Programmatic transaction control when needed
 Support for distributed transactions (JTA)
 Consistent transaction abstraction across different environments

6. Consistent Exception Handling:

 Translates technology-specific exceptions to consistent Spring exceptions

 Converts checked exceptions to meaningful unchecked exceptions
 Centralized exception handling mechanisms
 Better error reporting and debugging capabilities
 Reduces boilerplate exception handling code

7. Excellent Testing Support:

 Built-in testing framework with Spring TestContext

 Dependency injection for test objects
 Integration with JUnit and TestNG
 Mock object support for unit testing
 Test slices for focused testing (@WebMvcTest, @DataJpaTest)
 Easy mocking of Spring beans

8. Modular Architecture:

 Highly modular framework with 20+ separate modules

 Use only required modules to minimize footprint
 Core container, AOP, Data Access, Web, Test modules
 Easy to maintain, upgrade, and configure
 Supports microservices architecture

9. Rich Enterprise Features:

 Spring Security for comprehensive security solutions

 Spring Cache abstraction for caching strategies
 Task scheduling and asynchronous execution
 Email support and templating
 Validation framework integration
 Internationalization and localization support

10. Development Productivity:

 Reduces boilerplate code significantly

 Convention over configuration approach
 Auto-configuration capabilities (Spring Boot)
  Rich set of annotations for rapid development
 Excellent IDE support and tooling

11. Performance and Scalability:

 Efficient resource management

 Connection pooling and caching support
 Reactive programming support (Spring WebFlux)
 Horizontal scaling capabilities
 Optimized for cloud and containerized environments

12. Strong Community and Ecosystem:

 Large, active developer community

 Comprehensive documentation and tutorials
 Regular updates and maintenance
 Spring Boot for rapid application development
 Professional support and training available
 Extensive third-party integrations