Java Assignment
1. State four features of Java ?
Answer:-
• Platform Independent: Java code is compiled into bytecode, which can be run on any platform
that has a Java Virtual Machine (JVM). This is often summarized as "Write once, run anywhere."
• Object-Oriented: Java is a pure object-oriented language, meaning everything in Java (except
primitive data types) is an object. It supports concepts like encapsulation, inheritance, and
polymorphism.
• Simple: Java's syntax is relatively easy to learn, especially for programmers familiar with C++. It
has removed complex features like pointers and explicit memory management.
• Secure: Java provides a secure environment for running applications. It has built-in security
features, including bytecode verification, security manager, and no explicit pointers.
2. What is Garbage collection in java ?
Answer:-
Garbage collection in Java is an automatic memory management process. When an object is no
longer referenced by any part of the program, it becomes eligible for garbage collection. The
garbage collector then automatically reclaims the memory occupied by these unused objects,
preventing memory leaks and allowing the programmer to focus on application logic rather than
manual memory management.
3. How to create a package? Explain with example. ?
Answer:-
A package in Java is a way to organize related classes, interfaces, and sub-packages. It helps in
preventing naming conflicts and provides a way to control access.
Steps to create a package:
1. Declare the package at the top of the Java source file using the package keyword.
2. Save the Java file in a directory structure that matches the package name.
Example: Let's create a package named com.mycompany.utility with a class called
MathOperations.
1. Create the directory structure: myproject/src/com/mycompany/utility/
2. Create the MathOperations.java file inside myproject/src/com/mycompany/utility/:
3. Create a main class to use this package (e.g., MainApp.java in myproject/src/):
4. Describe the following methods related to String ? i) Replica () ii) compareTo () iii) charAt () ?
Answer:-
i) replace(): The replace() method is used to replace occurrences of a specified character
sequence (or character) with another character sequence (or character) within a string. It returns a
new string with the replacements; the original string remains unchanged because strings in Java
are immutable.
ii) compareTo() The compareTo() method is used to compare two strings lexicographically (based
on the Unicode value of each character).
iii) charAt() The charAt() method returns the character at a specified index in a string. The index is
zero-based, meaning the first character is at index 0, the second at index 1.
5. What are constructors? Explain two types of constructors with an example program. ?
Answer:-
Constructors are special methods in Java that are used to initialize objects. They have the same
name as the class and do not have a return type (not even void). Their primary purpose is to set
the initial state of an object when it is created using the new keyword.
Types of Constructors:
• i) Default Constructor (No-argument Constructor): If you don't explicitly define any
constructor in your class, Java automatically provides a public no-argument constructor.
This constructor initializes instance variables with their default values (e.g., 0 for numeric
types, false for booleans, null for object references).
• ii) Parameterized Constructor: A constructor that takes one or more arguments is called a
parameterized constructor. It allows you to initialize the instance variables of an object with
specific values provided during object creation. This is useful for ensuring that objects are
created in a valid and meaningful state.
6. What is the importance of the super keyword in inheritance? Illustrate with a suitable example ?
Answer:-
The super keyword in Java is a reference variable that is used to refer to the immediate parent
class object. Its importance in inheritance lies in three main scenarios:
• i) Invoking Parent Class Constructor: To call the constructor of the immediate parent class
from the child class's constructor. This ensures that the parent class's initialization logic is
executed before the child class's initialization.
• ii) Referring to Parent Class Instance Variables: To access instance variables of the parent
class when they are shadowed (have the same name) by instance variables in the child
class.
• iii) Invoking Parent Class Methods: To call methods of the parent class when they are
overridden (have the same signature) in the child class.
Example
// Parent class
class Animal {
String name;
public Animal(String name) {
this.name = name;
System.out.println("Animal constructor called for: " + name);
}
public void makeSound() {
System.out.println("Animal makes a sound.");
}
}
// Child class
class Dog extends Animal {
String breed;
public Dog(String name, String breed) {
// 1. Invoking Parent Class Constructor using super()
super(name); // Must be the rst statement in the constructor
this.breed = breed;
System.out.println("Dog constructor called for: " + name);
}
// Overriding the makeSound method
@Override
public void makeSound() {
// 3. Invoking Parent Class Method using super.methodName()
super.makeSound(); // Calls Animal's makeSound
System.out.println("Dog barks.");
}
public void displayDogInfo() {
// 2. Referring to Parent Class Instance Variable using super.variableName
System.out.println("Dog's Name (from Animal): " + super.name); // Although 'name' isn't
shadowed here, it demonstrates access
System.out.println("Dog's Name (from Dog - if shadowed): " + this.name); // Using 'this' is
also valid here
System.out.println("Dog's Breed: " + this.breed);
}
}
public class SuperKeywordExample {
public static void main(String[] args) {
Dog myDog = new Dog("Buddy", "Golden Retriever");
myDog.displayDogInfo();
myDog.makeSound(); // Calls the overridden makeSound in Dog, which then calls Animal's
makeSound
}
}
fi
7. What is abstract class and abstract method? Explain with an example.
Answer:-
In Java, abstract is a non-access modifier that can be applied to classes and methods. It signifies
incompleteness and the need for implementation by subclasses.
• Abstract Class: An abstract class is a class that cannot be instantiated directly. It can contain
both abstract methods (methods without a body) and concrete methods (methods with a body).
The purpose of an abstract class is to provide a common base or blueprint for its subclasses,
defining a common interface and potentially some common implementations. An abstract class
must be extended by a concrete subclass to be used.
// Abstract Class
abstract class Shape {
String color;
// Constructor for abstract class
public Shape(String color) {
this.color = color;
}
// Abstract method - no implementation
public abstract double getArea();
// Concrete method
public void displayColor() {
System.out.println("This shape is " + color);
}
}
// Concrete Subclass 1
class Circle extends Shape {
double radius;
public Circle(String color, double radius) {
super(color);
this.radius = radius;
}
// Implementing the abstract method
@Override
public double getArea() {
return Math.PI * radius * radius;
}
}
// Concrete Subclass 2
class Rectangle extends Shape {
double length;
• Abstract Method: An abstract method is a method declared without an implementation (i.e.,
without a method body). It is declared using the abstract keyword and ends with a semicolon.
Any class that contains one or more abstract methods must be declared as an abstract class.
Subclasses that extend an abstract class must provide an implementation for all inherited
abstract methods, unless they are also declared as abstract.
public Rectangle(String color, double length, double width) {
super(color);
this.length = length;
this.width = width;
}
// Implementing the abstract method
@Override
public double getArea() {
return length * width;
}
}
public class AbstractExample {
public static void main(String[] args) {
// Cannot instantiate abstract class directly
// Shape myShape = new Shape("Green"); // This would cause a compilation error
Circle circle = new Circle("Red", 5.0);
System.out.println("Circle Area: " + circle.getArea());
circle.displayColor();
System.out.println("-----");
Rectangle rectangle = new Rectangle("Blue", 4.0, 6.0);
System.out.println("Rectangle Area: " + rectangle.getArea());
rectangle.displayColor();
// Polymorphism with abstract class reference
Shape anotherShape = new Circle("Yellow", 2.5);
System.out.println("Another Shape Area: " + anotherShape.getArea());
anotherShape.displayColor();
}
}
8. Describe dynamic dispatch method with example. b) Explain the following terms with respect
to exception handling. i) try ii) catch iii) throw iv) finally
Answer:-
Dynamic Method Dispatch (Runtime Polymorphism): Dynamic method dispatch is a mechanism
in Java where a call to an overridden method is resolved at runtime rather than at compile time.
This occurs when a superclass reference variable holds an object of a subclass. The actual method
executed depends on the type of the object being referred to, not the type of the reference
variable. This is a key aspect of polymorphism in Java.
Example:
class Vehicle {
public void run() {
System.out.println("Vehicle is running.");
}
}
class Car extends Vehicle {
@Override
public void run() {
System.out.println("Car is running.");
}
}
class Bicycle extends Vehicle {
@Override
public void run() {
System.out.println("Bicycle is running.");
}
}
public class DynamicDispatchExample {
public static void main(String[] args) {
Vehicle myVehicle; // Declare a reference variable of type Vehicle
myVehicle = new Car(); // myVehicle refers to a Car object
myVehicle.run(); // Calls Car's run() method (dynamic dispatch)
myVehicle = new Bicycle(); // myVehicle refers to a Bicycle object
myVehicle.run(); // Calls Bicycle's run() method (dynamic dispatch)
myVehicle = new Vehicle(); // myVehicle refers to a Vehicle object
myVehicle.run(); // Calls Vehicle's run() method (dynamic dispatch)
}
}
In this example, at compile time, the compiler only knows that myVehicle is a Vehicle type and has
a run() method. However, at runtime, the JVM determines the actual type of the object pointed to
by myVehicle and invokes the appropriate run() method from Car, Bicycle, or Vehicle respectively.
b) Explain the following terms with respect to exception handling. Exception handling in Java
is a robust mechanism to manage runtime errors and maintain the normal flow of the application.
i) try: The try block is used to enclose the code segments that might throw an exception. If an
exception occurs within the try block, the control is immediately transferred to the corresponding
catch block (if one exists). If no exception occurs, the try block executes completely, and the catch
block is skipped. A try block must be followed by either a catch block or a finally block (or both).
ii) catch: The catch block immediately follows a try block and is used to handle a specific type of
exception that might be thrown in the try block. It contains the code that gets executed when the
corresponding exception occurs. You can have multiple catch blocks for a single try block to
handle different types of exceptions.
iii) throw: The throw keyword is used to explicitly throw an instance of an exception. This is
typically done when a specific condition is met within your code that signifies an error or an
exceptional situation. You can throw both checked and unchecked exceptions.
iv) nally: The finally block is an optional block that follows a try block and its catch blocks. The
code inside the finally block is always executed, regardless of whether an exception occurred in
the try block, was caught by a catchblock, or not caught at all. It is typically used for cleanup
operations, such as closing file streams, database connections, or releasing resources, to ensure
they are properly handled even in the presence of exceptions.
9. State four similarities between Interfaces and Classes. d) How to add class or interface to an
package ?
Answer:-
Four similarities between Interfaces and Classes are
• Can have methods: Both interfaces and classes can declare methods. (In Java 8+, interfaces can
have default and static methods with implementations, and private methods since Java 9).
• Can have variables: Both interfaces (which implicitly have public static final variables) and
classes can have variables (instance variables, static variables, and local variables).
• Can be extended/implemented: A class can extend another class, and an interface can extend
one or more interfaces. A class can implement one or more interfaces.
• Can be abstract: Both classes and interfaces can be declared as abstract, meaning they cannot
be instantiated directly. (All interfaces are inherently "abstract" in the sense that they cannot be
instantiated, but the abstract keyword on an interface is redundant).
b) How to add class or interface to a package?
To add a class or interface to a package in Java, you need to follow these steps:
• Declare the package in the source le: At the very top of your .java source file, before any
import statements or class/interface declarations, use the package keyword followed by the full
package name, terminated by a semicolon
• Match the directory structure: Save the .java file in a directory structure that exactly matches
the package name. Each dot (.) in the package name represents a directory level.
For the package com.example.myproject, the file MyClass.java should be saved in the
directory:your_project_root/com/example/myproject/MyClass.java
Similarly, MyInterface.java would be in: your_project_root/com/example/myproject/
MyInterface.java
When you compile this file, the compiled .class file will be placed in the corresponding package
directory within your output directory (or the same directory if not specified).
fi
fi
10. Describe the levels of access protection available for packages. ?
Answer:-
In Java, access modifiers control the visibility of classes, interfaces, methods, and variables. When
discussing levels of access protection for members within packages, we primarily consider:
• private:
◦ Scope: The member is accessible only within the same class where it is declared.
◦ Package Relevance: Not relevant for inter-package access as it's restricted to the
class itself.
• default (no keyword - package-private):
◦ Scope: The member is accessible only within the same package. It cannot be
accessed from outside the package.
◦ Package Relevance: This is the default access level if no other modifier is specified.
It provides a level of encapsulation within a package.
• protected:
◦ Scope: The member is accessible within the same package and by subclasses in any
package.
◦ Package Relevance: It allows members to be inherited and accessed by subclasses
even if they are in different packages, while still restricting access to unrelated
classes outside the package.
• public:
◦ Scope: The member is accessible from anywhere (from any class in any package).
◦ Package Relevance: Provides the widest visibility. public classes and interfaces are
visible to all other classes, and their public members are globally accessible.
11. State the use of static keyword ?
Answer:-
The static keyword in Java is a non-access modifier that indicates that a member (variable or
method) or a nested class belongs to the class itself, rather than to any specific instance (object) of
that class.
Uses of static keyword:
• static Variables (Class Variables):
◦ There is only one copy of a static variable per class, shared by all instances of that
class.
◦ They are initialized once when the class is loaded.
◦ They can be accessed directly using the class name (e.g., ClassName.staticVariable),
without needing an object instance.
◦ Commonly used for constants or shared data among all objects of a class.
• static Methods (Class Methods):
◦ Belong to the class, not to any specific object.
◦ Can be called directly using the class name (e.g., ClassName.staticMethod()).
◦ Cannot access non-static (instance) variables or call non-static methods directly
without an object reference, because they operate independently of specific object
state.
◦ Often used for utility functions that don't require object-specific data (e.g.,
Math.sqrt()).
• static Blocks (Static Initializer Block):
◦ A block of code that is executed only once when the class is loaded into memory,
before any objects are created or any static methods are called.
◦ Used for initializing static variables that require more complex logic than a single
expression.
• static Nested Classes (Static Inner Classes):
◦ A nested class declared with static can be instantiated without requiring an instance
of the outer class.
◦ It can only access static members of the outer class.
◦ Useful for creating helper classes that are logically grouped with an outer class but
don't need to be tied to its instance.
12. What is a thread ? Describe the complete life cycle of thread ?
Answer:-
In Java, a thread is the smallest unit of a process that can be executed independently. It's a
lightweight sub-process within a program that allows an application to perform multiple tasks
concurrently. Threads share the same memory space as the parent process, making
communication between them efficient. Multithreading refers to the ability of a CPU to execute
multiple threads at once.
Complete Life Cycle of a Thread: A thread in Java goes through several states from its creation
to its termination. These states are defined in the Thread.State enum (introduced in Java 5).
1. New:
◦ Description: A thread is in the "New" state when an instance of Thread is created
but before the start()method is invoked. The thread has been allocated resources,
but it's not yet eligible to be run by the JVM.
◦ Transition: From new Thread().
2. Runnable:
◦ Description: A thread enters the "Runnable" state after the start() method is called.
In this state, the thread is eligible to be run by the JVM's scheduler. It might be
currently running or waiting for its turn to run. The exact state (running or ready to
run) depends on the operating system's thread scheduler.
◦ Transition: From New (by calling start()).
3. Running:
◦ Description: This is a conceptual state within "Runnable" where the thread
scheduler has selected the thread, and it is actively executing its run() method.
◦ Transition: From Runnable (selected by the scheduler).
4. Blocked (Waiting for a monitor lock):
◦ Description: A thread enters the "Blocked" state when it tries to acquire a monitor
lock (e.g., using synchronized blocks/methods) but the lock is already held by
another thread. It waits until the lock becomes available.
◦ Transition: Attempting to enter a synchronized block/method when the lock is held
by another thread.
5. Waiting:
◦ Description: A thread is in the "Waiting" state when it explicitly waits for another
thread to perform a particular action. It remains in this state indefinitely until
another thread wakes it up. This typically occurs when methods like Object.wait(),
Thread.join() (without timeout), or LockSupport.park() are called.
◦ Transition: Calling Object.wait(), Thread.join(), or LockSupport.park().
◦ Transition out: Notified by another thread (using Object.notify() or
Object.notifyAll()), or the joined thread terminates, or LockSupport.unpark().
6. Timed Waiting:
◦ Description: Similar to "Waiting" but with a specified timeout. A thread enters this
state when it waits for another thread to perform an action for a specified maximum
time. It will automatically return to the "Runnable" state after the timeout period if
it hasn't been notified earlier. This occurs with methods like Thread.sleep(long
millis), Object.wait(long millis), Thread.join(long millis), LockSupport.parkNanos(long
nanos), or LockSupport.parkUntil(long deadline).
◦ Transition: Calling Thread.sleep(), Object.wait(long), Thread.join(long), etc.
◦ Transition out: Notified by another thread, or timeout expires.
7. Terminated (Dead):
◦ Description: A thread is in the "Terminated" state when its run() method has
completed its execution or when it has been explicitly terminated (e.g., by an
unhandled exception, though Thread.stop() is deprecated and should not be used).
Once a thread is terminated, it cannot be restarted.
◦ Transition: run() method completes, or an unhandled exception occurs.
