Winter 2022 PYQ with solutions

Download Question Paper : click here

Q.1

(a) Discuss significance of byte code

• Bytecode is a crucial part of the Java programming language, as it allows for platform independence and enables the "write once, run anywhere" paradigm.
• When a Java program is compiled, it is translated into bytecode, which is a highly optimized and compact binary format that can be executed on any platform with a Java Virtual Machine (JVM) installed.
• This means that a Java program can be written and compiled on one platform, and then distributed and executed on any other platform without modification.

(b) Explain Java garbage collection mechanism.

In Java, Garbage Collection is an automatic process that frees up memory used by objects that are no longer needed by the application. The Java Virtual Machine (JVM) is responsible for managing memory allocation and deallocation, including garbage collection.

When a Java program is executed, the JVM allocates memory for objects and variables as needed. When an object is no longer referenced by any part of the program, it becomes eligible for garbage collection. The JVM identifies these objects and automatically frees up the memory used by them.

The garbage collection mechanism in Java has several benefits, such as:

1. It eliminates memory leaks, which can lead to performance issues and crashes in programs.
2. It allows developers to focus on writing code without worrying about memory management.

Overall, the garbage collection mechanism in Java provides a reliable and efficient way to manage memory allocation and deallocation in Java programs.

(c) List OOP characteristics and describe inheritance with examples.

The main characteristics of OOP are:

1. Abstraction: Abstraction refers to the process of hiding complex implementation details of an object and presenting only the necessary information to the user. It helps in making the code simple and easy to understand.
2. Encapsulation: Encapsulation is the process of wrapping data and methods in a single unit. It helps in hiding the data and protects it from unauthorized access.
3. Inheritance: Inheritance is a mechanism that allows creating a new class from an existing class. It promotes code reusability and helps in avoiding code duplication.
4. Polymorphism: Polymorphism is the ability of an object to take multiple forms. It allows us to write code that can work with objects of different classes.

Inheritance is a key feature of OOP that allows creating a new class from an existing class. The new class is known as the derived class or subclass, and the existing class is known as the base class or superclass. The derived class inherits all the properties of the base class and can also add new properties or methods.

The syntax for creating a subclass is as follows:

class Subclass extends Superclass {
    // subclass members
}

There are several types of inheritance in Java:

1. Single inheritance
2. Multilevel inheritance
3. Hierarchical inheritance
4. Multiple inheritance

Example of inheritance -

// Parent class
class Animal {
  void eat() {
    System.out.println("The animal is eating.");
  }
}

// Child class inheriting from the Animal class
class Dog extends Animal {
  void bark() {
    System.out.println("The dog is barking.");
  }
}

// Example usage
public class Main {
  public static void main(String[] args) {
    // Creating a new Dog object
    Dog myDog = new Dog();

    // Calling the inherited "eat" method from the Animal class
    myDog.eat();

    // Calling the "bark" method from the Dog class
    myDog.bark();
  }
}

Q.2

(a) Explain constructor with the help of an example

In Java, a constructor is a special method that is used to initialize objects of a class. It has the same name as the class and is automatically called when an object of the class is created.

public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

This constructor can be used to create Person objects with specified name and age values like this:

Person p1 = new Person("John", 25);
Person p2 = new Person("Jane", 30);

(b) List out different methods available for String class in java and explain any two with proper example.

The String class in Java provides several methods to manipulate and process strings. Some of the commonly used methods are:

• length()
• equals(Object obj)
• toLowerCase()
• toUpperCase()
• charAt(int index)
• concat(String str)
• indexOf(int ch)

The toLowerCase() and toUpperCase() are two methods of the String class in Java used to convert the case of all the characters in a string.

The toLowerCase() method converts all the characters in a string to lowercase, and the toUpperCase() method converts all the characters to uppercase.

Example of toLowerCase() method:

String str = "Hello World";
String lowerCaseStr = str.toLowerCase();
System.out.println(lowerCaseStr);

Output -

hello world

Example of toUpperCase() method:

String str = "Hello World";
String upperCaseStr = str.toUpperCase();
System.out.println(upperCaseStr);

Output

HELLO WORLD

(c) Explain all access modifiers and their visibility as class members.

In Java, access modifiers are used to restrict the access level of class members (fields, methods, and nested classes) in the code. There are four access modifiers in Java:

1. Public: It has the widest scope and is accessible from anywhere within the application. Public members can be accessed by any class or method within the application.
2. Private: Private members can only be accessed within the same class in which they are declared. They cannot be accessed by any other class or method outside the class.
3. Protected: Protected members can be accessed within the same class, same package, and all the subclasses of the same package or different package.
4. Default: This is also known as the package-private access modifier, and it has the same scope as protected, but it is only accessible within the same package.

Here is a summary of the access modifiers and their visibility as class members:

Example Program -

public class AccessModifiersExample {

    public int publicVariable = 1;
    protected int protectedVariable = 2;
    int defaultVariable = 3;
    private int privateVariable = 4;

    public void publicMethod() {
        System.out.println("This is a public method");
    }

    protected void protectedMethod() {
        System.out.println("This is a protected method");
    }

    void defaultMethod() {
        System.out.println("This is a default method");
    }

    private void privateMethod() {
        System.out.println("This is a private method");
    }

    public static void main(String[] args) {
        AccessModifiersExample obj = new AccessModifiersExample();
        System.out.println("Public variable: " + obj.publicVariable);
        System.out.println("Protected variable: " + obj.protectedVariable);
        System.out.println("Default variable: " + obj.defaultVariable);
        System.out.println("Private variable: " + obj.privateVariable);

        obj.publicMethod();
        obj.protectedMethod();
        obj.defaultMethod();
        obj.privateMethod();
    }
}

OR

(c) Compare String with StringBuffer. Also, write a program to count the occurrence of a character in a string.

Here is a program to count the occurrence of a character in a string:

import java.util.Scanner;

public class CharacterCount {
   public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       System.out.print("Enter a string: ");
       String str = sc.nextLine();
       System.out.print("Enter a character: ");
       char ch = sc.next().charAt(0);
       int count = 0;
       for (int i = 0; i < str.length(); i++) {
           if (str.charAt(i) == ch) {
               count++;
           }
       }
       System.out.println("The character " + ch + " appears " + count + " times in the string.");
   }
}

Q.3

(a) What is the final class? Why they are used?

A final class is a class that cannot be subclassed or extended further. This means that once a final class is defined, it cannot be inherited by any other class.

Final classes are used primarily to prevent any further modification of the class's behavior, and to ensure that the class remains immutable.

Final classes are particularly useful in situations where the code must remain stable, secure, and free of any unwanted changes

The syntax for declaring a final class in Java is:

final class ClassName {
   // Class body
}

(b) Write exception handling mechanisms in JAVA.

In Java, exception handling is a mechanism that allows the programmer to handle runtime errors that may occur during the execution of a program. Exceptions can occur due to various reasons such as user input, hardware failure, network issues, and so on.

Java provides the following mechanisms for exception handling:

• try-catch block: It is used to catch and handle exceptions that occur within a block of code.

try {
    // code that may throw an exception
}
catch (Exception e) {
    // code to handle the exception
}

• throws keyword: It is used to declare that a method may throw an exception, but it does not handle the exception itself.

public void methodName() throws Exception {
    // code that may throw an exception
}

• throw keyword: It is used to explicitly throw an exception

throw new Exception("Error message");

• finally block: It is used to execute a block of code regardless of whether an exception was thrown or not.

try {
    // code that may throw an exception
}
catch (Exception e) {
    // code to handle the exception
}
finally {
    // code that always executes
}

(c) Explain Overloading and Overriding with example.

Overloading and Overriding are important concepts in Java that are used to achieve polymorphism, which is the ability of an object to take on multiple forms.

Overloading: It is the ability to define multiple methods in a class with the same name but with different parameters. Java chooses the appropriate method based on the number and type of parameters passed during the method call.

public class Calculator {
    public int add(int x, int y) {
        return x + y;
    }

    public int add(int x, int y, int z) {
        return x + y + z;
    }
}

In the above example, we have defined two methods with the same name add but with different parameters. If we call the add method with two parameters, the first method is executed, and if we call it with three parameters, the second method is executed.

Overriding: It is the ability of a subclass to provide its implementation for a method that is already defined in its superclass. The method in the subclass should have the same name, return type, and parameter list as the method in the superclass.

public class Animal {
    public void move() {
        System.out.println("The animal moves");
    }
}

public class Dog extends Animal {
    @Override
    public void move() {
        System.out.println("The dog runs");
    }
}

In the above example, the Dog class overrides the move method of its superclass Animal and provides its implementation. When we call the move method on a Dog object, the overridden method in the Dog class is executed instead of the method in the Animal class.

OR

Q.3

(a) How can you create packages in Java?

In Java, packages are used for grouping related classes and interfaces.

Define a package statement at the beginning of your Java file, before any import statements and class declarations. The syntax for creating a package is as follows:

package com.example.mypackage;

Here, com.example.mypackage is the name of the package.

if the package name is com.example.mypackage, the class file will be saved in the directory com/example/mypackage.

To use classes from a package in your Java code, you need to import them using the import statement. The syntax for importing a package is as follows:

import com.example.mypackage.MyClass;

(b) What is Inheritance? List out the different forms of Inheritance and explain any one with example.

Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a class to inherit the properties and behaviors of another class. The class that is being inherited from is known as the base class or superclass, and the class that inherits from the base class is known as the derived class or subclass.

There are five different forms of inheritance in Java:

1. Single inheritance: A derived class inherits properties and behaviors from a single base class.
2. Multilevel inheritance: A derived class inherits properties and behaviors from a base class, which itself is derived from another base class.
3. Hierarchical inheritance: Multiple derived classes inherit properties and behaviors from a single base class.
4. Multiple inheritance (through Interfaces): While Java does not support multiple inheritance through classes, it does support multiple inheritance through interfaces.
5. Hybrid inheritance: Java does not directly support hybrid inheritance (multiple inheritance combined with hierarchical inheritance). However, it can be achieved indirectly through a combination of interfaces and classes.

Let's take an example to understand single inheritance in Java:

class Animal {
   void eat() {
      System.out.println("Eating...");
   }
}

class Dog extends Animal {
   void bark() {
      System.out.println("Barking...");
   }
}

public class Main {
   public static void main(String[] args) {
      Dog d = new Dog();
      d.eat();
      d.bark();
   }
}

In this example, Dog class is derived from the Animal class using single inheritance.

(c) Explain the words super, static, final and this with the help of an example.

super: The super keyword in Java is used to refer to the superclass of the current object. It is used to call the constructor, method or variable of the parent class. For example:

class Parent {
   int value;
   Parent(int value) {
      this.value = value;
   }
}
class Child extends Parent {
   Child(int value) {
      super(value);
   }
}

In this example, super(value) is used to call the constructor of the Parent class with the value parameter.

static: The static keyword in Java is used to declare a variable or a method that belongs to the class rather than to instances of the class. This means that the variable or method can be accessed without creating an object of the class. For example:

class MyClass {
   static int count = 0;
   MyClass() {
      count++;
   }
}

In this example, count is a static variable that is incremented every time an object of MyClass is created. The value of count can be accessed without creating an object of MyClass by using MyClass.count.

final: The final keyword in Java is used to declare a variable or a method that cannot be modified or overridden. A final variable is a constant that cannot be reassigned once it has been initialized, while a final method cannot be overridden by a subclass. For example:

class MyClass {
   final int value = 10;
   final void printValue() {
      System.out.println(value);
   }
}

In this example, value is a final variable that is initialized with the value 10 and cannot be modified. printValue() is a final method that cannot be overridden by a subclass.

this: The this keyword in Java is used to refer to the current object. It is used to differentiate between instance variables and parameters or local variables that have the same name. For example:

class MyClass {
   int value;
   MyClass(int value) {
      this.value = value;
   }
   void printValue() {
      System.out.println("Value: " + this.value);
   }
}

In this example, this.value refers to the instance variable value, while value in the constructor parameter refers to the local variable. printValue() method uses this keyword to refer to the current object and print the value of instance variable.

Q.4

(a) List out various layout panes in JavaFX.

Here are various layout panes in JavaFX:

1. BorderPane: It is used to divide the scene into five different areas: top, bottom, left, right, and center.
2. GridPane: It is used to create a grid of nodes where each node can be placed in a specific row and column.
3. FlowPane: It is used to arrange the nodes in a flow, i.e., left to right and then top to bottom.
4. HBox: It is used to arrange the nodes in a single horizontal row.
5. VBox: It is used to arrange the nodes in a single vertical column.

(b) Explain the architecture of JavaF.

JavaFX is a GUI (Graphical User Interface) library for Java that enables developers to create rich and interactive applications for desktop, mobile, and other devices. It has a layered architecture, which provides a high level of flexibility to the developers. The architecture of JavaFX consists of the following components:

1. Scene Graph: The Scene Graph is a hierarchical structure that represents the visual elements of the user interface.
2. Graphics System: The Graphics System is responsible for rendering the Scene Graph on the screen.
3. Media Engine: The Media Engine provides support for playing audio and video files
4. Web Engine: The Web Engine provides support for displaying web pages within a JavaFX application.
5. CSS Engine: The CSS (Cascading Style Sheets) Engine is used to apply styles to the Scene Graph.
6. Animation Engine: The Animation Engine provides support for creating animations and transitions within the Scene Graph

(c) Discuss BufferedInputStream and BufferedOutputStream classes with an example.

BufferedInputStream and BufferedOutputStream are classes in Java that provide buffering capabilities to the input and output streams, respectively. They are used to improve the performance of reading from or writing to a file by reducing the number of I/O operations.

BufferedInputStream reads data from an input stream and stores it in an internal buffer. When a program requests data, BufferedInputStream returns data from the buffer instead of directly reading from the input stream. Similarly, BufferedOutputStream stores the output data in an internal buffer before writing it to the output stream.

Here is an example of using BufferedInputStream and BufferedOutputStream classes to copy the contents of one file to another:

import java.io.*;

public class FileCopy {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("input.txt");
            BufferedInputStream bis = new BufferedInputStream(fis);
            FileOutputStream fos = new FileOutputStream("output.txt");
            BufferedOutputStream bos = new BufferedOutputStream(fos);

            int data;

            while ((data = bis.read()) != -1) {
                bos.write(data);
            }

            bis.close();
            bos.close();

            System.out.println("File copied successfully.");
        } catch (IOException e) {
            System.out.println("An error occurred: " + e.getMessage());
        }
    }
}

In this example, we first create FileInputStream and FileOutputStream objects to read from and write to files. Then, we create BufferedInputStream and BufferedOutputStream objects to add buffering capabilities to the I/O streams.

Next, we read data from the input file using BufferedInputStream's read() method and write the data to the output file using BufferedOutputStream's write() method. We continue reading and writing until we reach the end of the input file.

Finally, we close both the input and output streams using close() method of BufferedInputStream and BufferedOutputStream respectively.

By using these buffered classes, we can improve the performance of file I/O operations, especially when reading or writing large amounts of data.

OR

Q.4

(a) List out JavaFX UI controls and explain any one in detail.

JavaFX provides a rich set of UI controls to create interactive and user-friendly graphical user interfaces (GUIs) for desktop applications. Some of the commonly used JavaFX UI controls are:

1. Button
2. Label
3. TextField
4. TextArea
5. CheckBox
6. RadioButton
7. ComboBox
8. ListView

Let's take an example of a Button

A button is a JavaFX UI control that represents a clickable area that can trigger an action or event when clicked.

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.stage.Stage;

public class MyButton extends Application {

    @Override
    public void start(Stage stage) {
        Button button = new Button("Click me!");
        Scene scene = new Scene(button, 200, 100);
        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) {
        launch();
    }

}

(b) Demonstrate animation effect in JavaFX

To create an animation effect in JavaFX, we can use the Timeline class along with key frames. Here's a short example:

import javafx.animation.TranslateTransition;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.layout.StackPane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;
import javafx.util.Duration;

public class AnimationExample extends Application {
    public void start(Stage stage) {
        Rectangle rect = new Rectangle(50, 50, 100, 100);
        rect.setFill(Color.BLUE);
        StackPane root = new StackPane(rect);
        Scene scene = new Scene(root, 200, 200);

        TranslateTransition tt = new TranslateTransition(Duration.seconds(2), rect);
        tt.setByX(100);
        tt.setAutoReverse(true);
        tt.setCycleCount(TranslateTransition.INDEFINITE);
        tt.play();

        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

(c) Create a class called Student. Write a student manager program to manipulate the student information from files by using FileInputStream and FileOutputStream.

import java.io.*;

public class Student {
    private String name;
    private int age;
    private String id;

    public Student(String name, int age, String id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public String toString() {
        return "Name: " + name + ", Age: " + age + ", ID: " + id;
    }

    public static void main(String[] args) {
        Student s1 = new Student("John Doe", 20, "12345");
        Student s2 = new Student("Jane Smith", 21, "67890");

        // write student information to file
        try {
            FileOutputStream fos = new FileOutputStream("students.dat");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s1);
            oos.writeObject(s2);
            oos.close();
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // read student information from file
        try {
            FileInputStream fis = new FileInputStream("students.dat");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Student s3 = (Student) ois.readObject();
            Student s4 = (Student) ois.readObject();
            ois.close();
            fis.close();
            System.out.println(s3);
            System.out.println(s4);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Q.5

(a) What is Java Collection?

• Java Collection is a framework provided in Java that helps in storing and manipulating a group of objects.
• It provides interfaces such as List, Set, Queue, etc., which can be implemented by classes such as ArrayList, LinkedList, HashSet, PriorityQueue, etc.
• The main objective of this framework is to provide a unified architecture to manipulate groups of objects regardless of their underlying implementation.
• Collections are widely used in Java programming for tasks such as sorting, searching, filtering, and data processing

(b) List out methods of Iterator and explain it.

The Iterator interface in Java provides a way to iterate over a collection of objects. It has three methods:

1. boolean hasNext(): This method returns a boolean value indicating whether there are more elements to be iterated or not.
2. Object next(): This method returns the next element in the iteration.
3. void remove(): This method removes the last element returned by the iterator from the underlying collection.

Using these methods, we can iterate over a collection, retrieve the elements one by one, and perform any necessary operations on them.

(c) Explain Set and Map in Java with example.

Set: A Set is a collection that does not allow duplicate elements. It is used when you want to store unique elements. In Java, the Set interface is implemented by several classes such as HashSet, TreeSet, and LinkedHashSet.

Example:

import java.util.*;

public class SetExample {
  public static void main(String[] args) {
    // create a set of integers
    Set<Integer> numbers = new HashSet<Integer>();

    // add some numbers to the set
    numbers.add(1);
    numbers.add(2);
    numbers.add(3);
    numbers.add(2); // adding duplicate element

    // print the set
    System.out.println("Set of Numbers: " + numbers);
  }
}

Output:

Set of Numbers: [1, 2, 3]

As we can see, the duplicate element '2' is not added to the Set because it already exists in the Set.

Map: A Map is a collection of key-value pairs. It is used to store data in a way that you can quickly and easily look up values based on their keys. In Java, the Map interface is implemented by several classes such as HashMap, TreeMap, and LinkedHashMap.

Example:

import java.util.*;

public class MapExample {
  public static void main(String[] args) {
    // create a map of students and their roll numbers
    Map<String, Integer> students = new HashMap<String, Integer>();

    // add some students to the map
    students.put("John", 101);
    students.put("Mary", 102);
    students.put("Bob", 103);

    // print the map
    System.out.println("Students and their Roll Numbers: " + students);

    // get the roll number of a student
    int rollNumber = students.get("Mary");
    System.out.println("Roll Number of Mary: " + rollNumber);
  }
}

Output:

Students and their Roll Numbers: {Bob=103, John=101, Mary=102}
Roll Number of Mary: 102

As we can see, the Map contains key-value pairs of students and their roll numbers. You can easily retrieve the roll number of a student by using their name as the key.

OR

Q.5

(a) What is Vector class?

• The Vector class in Java is a dynamic array-like data structure that is similar to ArrayList, but it is synchronized, which means that it is thread-safe.
• The Vector class provides several methods for adding, removing, and accessing elements in the vector. It also automatically resizes the vector when the number of elements exceeds its capacity.
• The Vector class is useful in situations where multiple threads need to access and modify the same vector simultaneously, as it ensures that only one thread can access the vector at a time, thus preventing any potential concurrency issues.

import java.util.Vector;

public class VectorExample {
    public static void main(String[] args) {
        // create a new vector
        Vector<String> vector = new Vector<>();

        // add elements to the vector
        vector.add("apple");
        vector.add("banana");
        vector.add("orange");
    }
}

(b) Describe with diagram the life cycle of Thread.

Thread lifecycle represents the various states that a thread goes through during its lifetime. In Java, the thread lifecycle consists of six states: New, Runnable, Blocked, Waiting, Timed Waiting, and Terminated

1. New: When a thread is created, it is in the new state. The thread is not yet scheduled for execution and has not started running.
2. Runnable: When the thread scheduler selects the thread to run, it enters the runnable state. The thread is now eligible to run but may not be currently executing due to other threads running on the CPU.
3. Blocked: If a thread is waiting for a monitor lock or a resource held by another thread, it enters the blocked state. The thread is temporarily suspended until the lock is available.
4. Waiting: When a thread is waiting for some condition to occur, it enters the waiting state. A waiting thread can be notified to wake up by another thread.
5. Timed Waiting: When a thread waits for a certain amount of time, it enters the timed waiting state. A timed waiting thread can be notified to wake up by another thread or it can wake up automatically when the time expires.
6. Terminated: When a thread completes its execution, it enters the terminated state.

(c) Explain synchronization in Thread with suitable example.

• Synchronization is the process of controlling the access of shared resources among multiple threads in order to avoid race conditions and data inconsistency.
• When a method or a block of code is declared as synchronized, only one thread can execute it at a time, while all other threads will be blocked until the synchronized block is released.

Here's an example to illustrate synchronization in Java:

public class Counter {
   private int count;

   public synchronized void increment() {
      count++;
   }

   public synchronized int getCount() {
      return count;
   }
}

public class MyThread extends Thread {
   private Counter counter;

   public MyThread(Counter counter) {
      this.counter = counter;
   }

   public void run() {
      for (int i = 0; i < 10000; i++) {
         counter.increment();
      }
   }
}

public class Main {
   public static void main(String[] args) throws InterruptedException {
      Counter counter = new Counter();
      MyThread thread1 = new MyThread(counter);
      MyThread thread2 = new MyThread(counter);
      thread1.start();
      thread2.start();
      thread1.join();
      thread2.join();
      System.out.println(counter.getCount());
   }
}

In this example, the Counter class has two synchronized methods: increment() and getCount(). The increment() method increments the count variable by one, while the getCount() method returns the current value of count. The MyThread class represents a thread that repeatedly calls the increment() method on a Counter object.

In the main method of the Main class, two MyThread objects are created and started. They both increment the count variable of the shared Counter object. The join() method is called on both threads to wait for them to finish before printing out the final value of count.

Without synchronization, the final value of count could be unpredictable, as the two threads might try to access and modify the variable at the same time. However, since the increment() method is declared as synchronized, only one thread can execute it at a time, ensuring that the value of count is incremented correctly and consistently.