Solved[December 2023] MCS024 - OOP And Java Programming

Question 1(a). What is a class ? How does it accomplish data hiding ? Explain with an example. (5 Marks)

Answer:

A class in object-oriented programming (OOP) is a blueprint for creating objects (instances), which are instances of the class. It defines the attributes (data) and methods (functions) that the objects of the class will have.

Data hiding, also known as encapsulation, is a key concept in OOP that allows the internal details of a class to be hidden from the outside world. This means that the implementation details of a class are not accessible to code outside the class, which helps in protecting the integrity of the data and prevents unintended modifications.

Here is a java code example for represeting class and data hiding.

public class BankAccount {
    private String accountNumber; // Encapsulated attribute
    private double balance; // Encapsulated attribute

    // Constructor
    public BankAccount(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    // Method to deposit money
    public void deposit(double amount) {
        balance += amount;
    }

    // Method to withdraw money
    public void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("Insufficient funds");
        }
    }

    // Getter method for account number (optional)
    public String getAccountNumber() {
        return accountNumber;
    }

    // Getter method for balance (optional)
    public double getBalance() {
        return balance;
    }

    // Main method for example usage
    public static void main(String[] args) {
        BankAccount account1 = new BankAccount("123456789", 1000);
        account1.deposit(500);
        account1.withdraw(200);
        System.out.println(account1.getBalance()); // Output: 1300.0
        System.out.println(account1.getAccountNumber()); // Output: 123456789
    }
}

In this Java example, the BankAccount class has private attributes accountNumber and balance, which are encapsulated within the class. These attributes can only be accessed and modified through the class methods (deposit and withdraw). Additionally, getter methods (getAccountNumber and getBalance) are provided for accessing these attributes from outside the class.

Question 1(b). Differentiate between AWT and Swing components. Give suitable example for each. (5 Marks)

Answer:

AWT (Abstract Window Toolkit) and Swing are both Java libraries used for creating graphical user interfaces (GUIs). However, they have some differences in terms of functionality and appearance.

AWT -AWT is the original GUI toolkit for Java. The components of AWT are lightweight because they rely on the native platform's GUI components. AWT components have a platform-dependent look and feel. AWT provides fewer components compared to Swing.

Code example of AWT Components -

import java.awt.*;
import java.awt.event.*;

public class AWTButtonExample {
    public static void main(String[] args) {
        Frame frame = new Frame("AWT Button Example");
        Button button = new Button("Click Me");
        button.setBounds(100, 100, 80, 30);
        frame.add(button);
        frame.setSize(300, 200);
        frame.setLayout(null);
        frame.setVisible(true);
    }
}

Swing - it is built on top of AWT but provides a more sophisticated set of GUI components. Components are lightweight, meaning they are not dependent on the native platform's components, resulting in consistent appearance across different platforms. Swing provides a rich set of components, including advanced ones like tables, trees, and tabbed panes.

Example of Swing Components:

import javax.swing.*;

public class SwingButtonExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Swing Button Example");
        JButton button = new JButton("Click Me");
        button.setBounds(100, 100, 120, 50);
        frame.add(button);
        frame.setSize(300, 200);
        frame.setLayout(null);
        frame.setVisible(true);
    }
}

Question 1(c). Explain the relationship between inheritance and polymorphism. Give example of each. (5 Marks)

Answer:

Inheritance and polymorphism are two fundamental concepts in object-oriented programming, and they are closely related.

Inheritance - Inheritance is a mechanism where a new class (subclass or derived class) is created from an existing class (superclass or base class). The subclass inherits the properties and behaviors (methods and fields) of the superclass. It allows code reusability and promotes the concept of "is-a" relationship.

Code Example of Inheritance

// Superclass
class Animal {
    void makeSound() {
        System.out.println("Some generic sound");
    }
}

// Subclass inheriting from Animal
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof");
    }
}

In this example, Dog is a subclass of Animal. It inherits the makeSound() method from the Animal class and overrides it to provide its own implementation.

Polymorphism - It is the ability of a single interface (or method) to represent multiple underlying implementations. It allows objects of different classes to be treated as objects of a common superclass, leading to code flexibility and extensibility. Polymorphism is achieved through method overriding and method overloading.

Code example of Polymorphism -

class Shape {
    void draw() {
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }
}

class Drawing {
    void drawShape(Shape shape) {
        shape.draw();
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Drawing drawing = new Drawing();
        Shape shape1 = new Shape();
        Shape shape2 = new Circle();
        drawing.drawShape(shape1); // Output: Drawing a shape
        drawing.drawShape(shape2); // Output: Drawing a circle
    }
}

In this example, Shape is a superclass with a method draw(). Circle is a subclass of Shape and overrides the draw() method to draw a circle. The Drawing class demonstrates polymorphism by accepting objects of type Shape and invoking their draw() methods, which are dynamically bound to the appropriate implementation based on the actual object type (Shape or Circle).

Quesiton 1(d). What is Java Bean ? Briefly discuss the features of Java Bean. (5 Marks)

Answer:

A Java Bean is a reusable software component model for Java. It's a simple, reusable software component that can be manipulated visually in a builder tool. Here are the key features of Java Beans:

Overall, Java Beans provide a standardized way to create reusable components in Java, promoting code reuse, modular design, and interoperability.

Quesiton 1(e). Explain why main() method is not included in writing a Java applet program using an applet coding.

Answer:

In Java, applets are special types of programs that are designed to be embedded within web pages and executed in a web browser. Unlike standalone Java applications that use the main() method as an entry point, Java applets use a different lifecycle and are loaded, initialized, and executed by the web browser.

Here's why the main() method is not included in writing a Java applet program using applet coding:

Questionn 1(f). Compare structured programming and object oriented programming. (5 Marks)

Answer:

Structured programming and object-oriented programming (OOP) are two different programming paradigms, each with its own principles, advantages, and use cases. Here's a comparison between the two:

Question 1(g). Discuss the utility of final and finalize keywords in Java. Give example code for each. (5 Marks)

Answer:

In Java, the final keyword is used to declare constants, mark methods that cannot be overridden, and prevent subclassing. On the other hand, the finalize() method is used for garbage collection, allowing an object to perform any necessary cleanup operations before it is reclaimed by the garbage collector. Let's discuss each in detail with examples:

Final Keyword is used when we declare a variable as final, its value cannot be changed once initialized or a method as final, it cannot be overridden by subclasses or When we declare a class as final, it cannot be subclassed.

Code example for final keyword usage

// Using final for constants
public class ConstantsExample {
    public static final double PI = 3.14159;
    public static final int MAX_SIZE = 100;
    
    public static void main(String[] args) {
        // Trying to reassign a final variable will result in a compilation error
        // PI = 3.14; // Compilation error: cannot assign a value to final variable PI
    }
}


// Using final for methods
class Parent {
    public final void display() {
        System.out.println("This method cannot be overridden.");
    }
}

class Child extends Parent {
    // Trying to override the final method will result in a compilation error
    public void display() {} // Compilation error: display() in Child cannot override display() in Parent
}


// Using final for classes
final class FinalClass {
    // Class implementation
}

// Trying to inherit from a final class will result in a compilation error
class SubClass extends FinalClass {} // Compilation error: cannot inherit from final FinalClass

                        

The finalize() method is called by the garbage collector before reclaiming an object's memory. It's used for cleanup operations or releasing resources. It's generally discouraged to rely on for critical resource cleanup due to uncertainty about when it will be called.

Code example for finalize() method usage

class Resource {
    public void finalize() {
        // Cleanup operations such as closing files or releasing network connections
        System.out.println("Resource cleanup performed.");
    }
}

public class FinalizeExample {
    public static void main(String[] args) {
        Resource resource = new Resource();
        
        // Make the resource eligible for garbage collection
        resource = null;
        
        // Request garbage collection
        System.gc();
        
        // Although we request garbage collection, we can't guarantee when finalize() will be called
        System.out.println("End of main method.");
    }
}

Question 1(h). How does datagram socket differ from stream socket ? (5 Marks)

Answer:

In Java, DatagramSocket and StreamSocket are two different types of sockets used for communication over a network, each with its own characteristics and usage scenarios. Here's how they differ:

DatagramSocket - It is used for sending and receiving datagrams (packets) over a connectionless protocol such as UDP (User Datagram Protocol). DatagramSocket does not establish a persistent connection between the client and the server. Instead, it sends individual packets of data known as datagrams. it is suitable for scenarios where real-time or loss-tolerant communication is required, such as multimedia streaming, online gaming, or network monitoring. DatagramSocket does not guarantee delivery or order of packets, as it operates in an unreliable manner. It also does not provide error checking or flow control mechanisms.

StreamSocket - it is also known as a TCP socket, is used for establishing a reliable, bidirectional, byte-oriented communication channel between a client and a server. StreamSocket establishes a connection-oriented communication channel between the client and the server before data exchange begins. it ensures reliable data delivery, in-order data transmission, and error detection through mechanisms like sequence numbers, acknowledgment, and retransmission. StreamSocket is suitable for scenarios where data integrity, reliability, and ordered delivery are critical, such as file transfer, web browsing, or client-server applications.

Question 2(a). Write a Java applet to display. “Java is an object oriented programming language” in red color. Support your code with suitable comments. (5 marks)

Answer:

Java applet code to display the text "Java is an object-oriented programming language" in red color:

import java.applet.*;
import java.awt.*;

public class RedTextApplet extends Applet {
    public void paint(Graphics g) {
        // Set the color to red
        g.setColor(Color.RED);
        
        // Set the font size and style
        g.setFont(new Font("Arial", Font.BOLD, 16));
        
        // Draw the text at specified coordinates
        g.drawString("Java is an object-oriented programming language", 20, 20);
    }
}
Explanation: 
The RedTextApplet class extends the Applet class, which is the base class for applets in Java. 
The paint() method is overridden to perform custom drawing operations. Inside the paint() method: 
setColor() method is used to set the drawing color to red. 
setFont() method is used to set the font for drawing the text. In this example, "Arial" font with bold style and size 16 is used. 
drawString() method is used to draw the specified text at the specified coordinates (x=20, y=20). 
When the applet is executed, it will display the text "Java is an object-oriented programming language" in red color at the specified coordinates.

Question 2(b). What is a layout manager ? Explain the flow layout and border layout. Also explain how a layout is set. (8 marks)

Answer:

Layout manager in Java is responsible for organizing and positioning components within a container. Let's learn more about these two common layout managers: FlowLayout and BorderLayout.

FlowLayout arranges components in a left-to-right, top-to-bottom flow. This means that when one row is filled, the next component moves to the next row. It's handy for dynamically arranging components based on the container's size.

For instance, to use FlowLayout, we can set it by calling setLayout(new FlowLayout()).

On the other hand, BorderLayout divides the container into five regions: North, South, East, West, and Center. Each region can hold only one component, which is stretched to fit the available space within its region. This layout is useful for creating typical application layouts, like having a main content area with optional side panels.

To employ BorderLayout, we set it using setLayout(new BorderLayout()), and then we add components to specific regions using add(component, BorderLayout.NORTH) for example.

Setting a layout is straightforward. We just call the setLayout() method of the container and pass in an instance of the desired layout manager. From then on, any components we add to that container will be arranged according to the rules of the layout manager we've chosen.

Question 2(c). What are packages in Java ? How do we create a package in Java ? What are the steps to add Classes and Interfaces in a package ? (7 marks)

Answer:

Packages in Java help us organize classes and interfaces into namespaces, providing a way to group related code and avoid naming conflicts. Here's how we can create a package in Java and add classes and interfaces to it:

src/
└── com/
    └── example/
        └── package/

Here's an example of how we can create a simple package and add classes and interfaces to it:

// File: src/com/example/package/MyClass.java
package com.example.package;

public class MyClass {
    // Class implementation
}

// File: src/com/example/package/MyInterface.java
package com.example.package;

public interface MyInterface {
    // Interface methods
}

In this example, MyClass and MyInterface belong to the com.example.package package. We've organized them into the appropriate directory structure under the src directory. This way, we've created a package in Java and added classes and interfaces to it.

Question 3(a). Differentiate between thread and process. Explain Java thread model using thread life cycle. (7 marks)

Answer:

Differentiating between a thread and a process, a thread represents the smallest unit of execution within a process, while a process is an instance of a running program comprising one or more threads. Threads share the same memory space within a process, enabling communication and cooperation.

In Java, the thread model revolves around the java.lang.Thread class and related APIs. Threads in Java undergo a life cycle with distinct states

To utilize threads in Java, we create instances of the Thread class or implement the Runnable interface. We control thread behavior using methods like start(), join(), sleep(), and wait(), enabling concurrent and parallel execution of tasks within a Java program.

Question 3(b). Compare Applet and Servlet. Write the steps to incorporate applet in a webpage. (8 marks)

Answer:

Applet- It is a small Java program that runs within a web browser. It is typically used for client-side scripting, providing interactive and dynamic content on a web page. Applets have direct access to the client's system resources, such as the file system and network connections. They are embedded within HTML pages using the <applet> tag.

Servlet-It is a Java program that runs on the server side. It handles client requests and generates dynamic content that is sent back to the client. Servlets run within a servlet container (e.g., Apache Tomcat), which manages their lifecycle and handles communication with clients. Servlets have access to server-side resources and can interact with databases, perform authentication, and more.

Steps to incorporate an applet in a webpage:

Question 3(c). Explain method overriding in Java using a program in Java. (5 marks)

Answer:

Method overriding in Java allows a subclass to provide a specific implementation of a method that is already defined in its superclass. When a subclass overrides a method, it provides its own implementation of the method, which is used instead of the superclass's implementation when the method is called on an instance of the subclass.

Simple program in java for method overiding:-

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    // Override the makeSound() method
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}

public class MethodOverridingExample {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // Output: Animal makes a sound
        
        Dog dog = new Dog();
        dog.makeSound(); // Output: Dog barks
        
        // Upcasting: Animal reference to Dog object
        Animal anotherDog = new Dog();
        anotherDog.makeSound(); // Output: Dog barks (Dynamic method dispatch)
    }
}

Question 4(a). Write a Java program for writing files in “C:\javafiles\” location. Support your program with suitable comments. (7 marks)

Answer:

Java program that writes files to the "C:\javafiles" location:

import java.io.FileWriter;
import java.io.IOException;

public class FileWritingExample {
    public static void main(String[] args) {
        // Specify the directory path
        String directoryPath = "C:\javafiles\";
        
        // Specify the file name
        String fileName = "example.txt";
        
        // Specify the file content
        String fileContent = "This is a sample file content.";

        // Create FileWriter and BufferedWriter objects
        FileWriter fileWriter = null;
        try {
            // Create FileWriter with the specified file path
            fileWriter = new FileWriter(directoryPath + fileName);
            
            // Write the content to the file
            fileWriter.write(fileContent);
            
            // Print success message
            System.out.println("File '" + fileName + "' created successfully at location: " + directoryPath);
        } catch (IOException e) {
            // Handle IO exception
            e.printStackTrace();
        } finally {
            // Close FileWriter to release resources
            try {
                if (fileWriter != null) {
                    fileWriter.close();
                }
            } catch (IOException e) {
                // Handle IO exception
                e.printStackTrace();
            }
        }
    }
}

Quesiton 4(b). Write the steps of JDBC in establishing a connection for creating dynamic website for INSERT/UPDATE the attendance record for students of a college. (7 Marks)

Answer:

Steps of JDBC in establishing a connection for creating a dynamic website to INSERT/UPDATE the attendance record for students of a college:

• Step 1. Import the necessary JDBC packages, including java.sql.*, to enable JDBC functionality in your Java code.
• Step 2. Load and register the appropriate JDBC driver for the database we are using. Different databases require different JDBC drivers. For example, if we're using MySQL, you would load the MySQL JDBC driver using Class.forName("com.mysql.cj.jdbc.Driver").
• Step 3. Create a connection object using the DriverManager.getConnection() method, passing the database URL, username, and password as parameters. The database URL specifies the location of the database.
• Step 4. Create an SQL statement (INSERT or UPDATE) to perform the desired database operation (e.g., adding or updating attendance records for students).
• Step 5. Execute the SQL statement using the Statement or PreparedStatement object obtained from the connection. If you are executing a parameterized SQL statement, use a PreparedStatement to prevent SQL injection attacks.
• Step 6. If your SQL statement returns a result set (e.g., after executing a SELECT query), use the ResultSet object to process the returned data.
• Step 7. Close all database resources (connection, statement, result set) using the close() method to release database connections and prevent resource leaks.

Question 4(c). What is synchronization ? Explain how methods are synchronized in Java with the help of an example. (6 Marks)

Answer:

Synchronization in Java is a technique used to control access to shared resources or critical sections of code by multiple threads. It ensures that only one thread can access the shared resource or critical section at a time, preventing concurrent access and potential data corruption or inconsistency.

In Java, methods can be synchronized using the `synchronized` keyword. When a method is declared as synchronized, only one thread can execute that method at a time. Other threads attempting to call the synchronized method must wait until the executing thread releases the lock.

Example demonstrating how methods are synchronized in Java:

public class Counter {
    private int count = 0;

    // Synchronized method to increment the counter
    public synchronized void increment() {
        count++;
    }

    // Synchronized method to decrement the counter
    public synchronized void decrement() {
        count--;
    }

    // Method to get the current value of the counter
    public int getCount() {
        return count;
    }
}

Question 5. Write short notes on the following : 4×5=20 Marks
(a) Object serialization
(b) Liberals and its types
(c) Servlet life cycle
(d) Garbage collection
(e) Role of cookies in session handling

Answer:

(a) Object Serialization: It is the process of converting an object into a byte stream so that it can be persisted to a file, sent over a network, or stored in a database. In Java, serialization is achieved by implementing the Serializable interface. Serialized objects can be deserialized back into Java objects, allowing for the preservation of object state across different executions of a program or during communication between different Java applications.

(b) Libraries and its types: Libraries in software development refer to collections of reusable code modules or functions that provide specific functionalities to developers. There are two main types of libraries:

• Static Libraries, also known as archives, static libraries are collections of precompiled object files (.o files) that are linked with a program at compile time. They are embedded directly into the executable binary and remain fixed once linked.
• Dynamic libraries, also known as shared libraries or DLLs (Dynamic Link Libraries), are loaded into memory only when needed at runtime. They allow for code reuse across multiple applications and facilitate more efficient memory usage by sharing code among different processes.

(c) Servlet Life Cycle:It refers to the sequence of events that occur from the creation to the destruction of a servlet instance within a Java web application. The servlet life cycle consists of several stages:

• Initialization: The servlet container initializes the servlet by calling its init() method. This method is called only once during the servlet's lifetime and is used to perform any necessary initialization tasks.
• Handling Client Requests: Once initialized, the servlet can handle client requests by processing HTTP request messages sent by clients (e.g., web browsers). Each request is processed in a separate thread, allowing the servlet to handle multiple requests concurrently.
• Destroying the Servlet: When the servlet container determines that the servlet is no longer needed (e.g., when the web application is shut down), it calls the servlet's destroy() method to release any allocated resources and perform cleanup tasks.

(d) Garbage Collection:Garbage collection is a memory management technique used in programming languages like Java to automatically reclaim memory occupied by objects that are no longer in use. In Java, the garbage collector periodically identifies and removes unreferenced objects from memory, freeing up space for new objects. The process of garbage collection helps prevent memory leaks and improves the efficiency of memory usage in Java programs.

(e) Role of Cookies in Session Handling:Cookies are small pieces of data sent from a web server to a user's web browser and stored on the user's device. In session handling, cookies play a crucial role in maintaining state information between multiple HTTP requests from the same client. When a user visits a website, the server can create a session and associate it with a unique session identifier (session ID). This session ID is then stored in a cookie and sent back to the client's browser. Subsequent requests from the client include the session ID cookie, allowing the server to retrieve the associated session data and maintain the user's session state across multiple requests. Cookies can also be used to store other types of data, such as user preferences or shopping cart items, for personalized user experiences.