Java Programming using Linux, Semester 5, First Internal Exam, September 2023

 

Section A

Answer any 5 questions. Each question carries 2 marks.

  1. VM (Java Virtual Machine) and Byte Code:
    • JVM (Java Virtual Machine) is an integral part of the Java Runtime Environment (JRE) responsible for executing Java applications. It provides a platform-independent execution environment for Java programs. The JVM interprets and executes Java bytecode.
    • Bytecode is a low-level, platform-independent representation of a Java program. When you compile a Java source code file (.java), it gets converted into bytecode (.class) by the Java compiler. This bytecode can be executed on any system with a compatible JVM, making Java a "write once, run anywhere" language.
  2. Polymorphism:
    • Polymorphism is a fundamental concept in object-oriented programming (OOP) that allows objects of different classes to be treated as objects of a common super class. It enables you to write code that can work with objects of multiple related classes without knowing their specific types.
    • Polymorphism is typically achieved through method overriding and method overloading. Method overriding allows a subclass to provide a specific implementation of a method defined in its superclass, while method overloading allows multiple methods with the same name but different parameter lists to coexist in a class.
  3. Constructor:
    • A constructor in Java is a special type of method that is called when an object of a class is instantiated (created). It is used to initialize the object's state, allocate resources, and perform any necessary setup tasks.
    • Constructors have the same name as the class and do not have a return type, not even void. They can be overloaded, meaning a class can have multiple constructors with different parameter lists.
    • If you don't explicitly define a constructor in your class, Java provides a default constructor with no arguments.
  4. Interface:
    • In Java, an interface is a blueprint for a class that defines a set of abstract methods (methods without implementations) that any class implementing the interface must provide. It specifies what a class should do but not how it should do it.
    • Interfaces can also contain constants (public static final fields) and default methods (methods with implementations) starting from Java 8. Multiple interfaces can be implemented by a single class, allowing for multiple inheritance of behavior.
  5. Abstract Class and Methods:
    • An abstract class in Java is a class that cannot be instantiated on its own and is often used as a base class for other classes. It can contain both abstract methods (methods without implementations) and concrete methods (methods with implementations).
    • Abstract methods declared in an abstract class are meant to be overridden by concrete subclasses that extend the abstract class. Abstract classes are defined using the abstract keyword.
  6. Four methods in the String class (part of Java's standard library):
    • length(): Returns the length (number of characters) of the string.
    • charAt(int index): Returns the character at the specified index in the string.
    • substring(int beginIndex): Returns a new string that is a substring of the original string starting from the specified index.
    • indexOf(String str): Returns the index of the first occurrence of the specified substring within the string, or -1 if not found.

 

                                                                                     (5 x 2 =10 Marks)

 

Section B

Answer any 3 questions. Each question carries 5 marks.

 

  1. Java Environment: The Java environment refers to the runtime and development environment for Java programming. It encompasses various components and tools used for developing, compiling, and executing Java applications:
    • Java Development Kit (JDK): The JDK includes the Java compiler (javac), Java Virtual Machine (JVM), and a set of libraries and tools for developing Java applications. It is used by developers to write, compile, and debug Java code.
    • Java Runtime Environment (JRE): The JRE consists of the JVM and the Java standard libraries. It is necessary for running Java applications but does not include development tools like the JDK.
    • Integrated Development Environments (IDEs): IDEs like Eclipse, IntelliJ IDEA, and NetBeans provide development environments with code editors, debugging tools, and project management features for Java developers.
    • Class Libraries: Java includes a vast collection of class libraries (APIs) that provide pre-written code for various tasks, such as data manipulation, file I/O, networking, and user interface development.
    • applications are platform-independent.
  2. Use of the super Keyword:
    • In Java, the super keyword is used to refer to the immediate superclass of a class. It can be used in two main contexts:
      1. To Call Superclass Constructors: When creating an instance of a subclass, you can use super to call a constructor in the superclass. This is typically done in the subclass's constructor to initialize the inherited properties.
      2. To Access Superclass Members: super can also be used to access methods or fields of the superclass when they are overridden or shadowed in the subclass. It helps distinguish between the superclass and subclass members with the same name.
  3. Method Overloading vs. Constructor Overloading:
    • Method Overloading:
      • Method overloading refers to the ability to define multiple methods in a class with the same name but different parameter lists.
      • It is used to provide multiple ways of using the same method, often with different argument types or numbers of arguments.
      • Method overloading does not have to involve inheritance and can be done within a single class.
      • Return types may be the same or different for overloaded methods.
    • Constructor Overloading:
      • Constructor overloading refers to defining multiple constructors in a class with different parameter lists.
      • It is used to provide multiple ways to create instances of a class with different initialization options.
      • Constructor overloading is typically used to initialize the object's state when it is created.
      • Constructors do not have a return type, not even void.
      • Constructors are called when an object is instantiated using the new keyword.
  1. Arrays in Java:
    • In Java, an array is a data structure used to store a fixed-size, ordered collection of elements of the same data type. Arrays are declared and initialized with a specific size when they are created.
    • Key points about arrays in Java:
      • Declaration: To declare an array, you specify the data type of the elements it will hold, followed by square brackets ([]), and then the array name. For example, int[] numbers; declares an integer array.
      • Initialization: You can initialize an array at the time of declaration or later using the new keyword. For example, int[] numbers = new int[5]; creates an integer array of size 5.
      • Accessing Elements: Elements in an array are accessed by their index, starting from 0. For example, numbers[0] accesses the first element.
      • Length: You can find the length (number of elements) of an array using the length property. For example, int length = numbers.length;.
      • Fixed Size: Arrays have a fixed size, meaning you cannot change their size once they are created. To add or remove elements dynamically, you might use other data structures like ArrayList in Java.

 

Section C

Answer any 1 question. The question carries 15 marks

  1. Object-Oriented Programming (OOP) Concepts: Object-Oriented Programming is a programming paradigm that organizes code into objects, which are instances of classes, and promotes the following key concepts:
  • Class: A class is a blueprint or template for creating objects. It defines the properties (attributes) and behaviors (methods) that the objects of the class will have.
  • Object: An object is an instance of a class. It represents a real-world entity and encapsulates data (attributes) and the methods (functions) that operate on that data.
  • Encapsulation: Encapsulation is the concept of bundling data (attributes) and methods that operate on that data into a single unit (an object). It hides the internal details of an object and exposes a controlled interface for interaction.
  • Inheritance: Inheritance allows a new class (subclass or derived class) to inherit the properties and behaviors of an existing class (superclass or base class). It promotes code reuse and the creation of hierarchical relationships between classes.
  • Polymorphism: Polymorphism allows objects of different classes to be treated as objects of a common superclass. It enables dynamic method invocation and allows for method overriding and method overloading.
  • Abstraction: Abstraction is the process of simplifying complex systems by breaking them into smaller, more manageable parts. In OOP, classes and objects provide abstraction by hiding unnecessary details and exposing only what is relevant.
  1. Inheritance with Examples: Inheritance is one of the core concepts of object-oriented programming, allowing one class to inherit the properties and behaviors of another class. The class that is inherited from is called the superclass or base class, and the class that inherits from it is called the subclass

 

In Java, there are several types of inheritance, each serving specific purposes and modeling different relationships between classes. The main types of inheritance in Java include:

1.    Single Inheritance:

·         Single inheritance refers to a situation in which a class extends (inherits from) only one superclass.

·         In Java, every class can have at most one direct superclass. This helps maintain simplicity and avoids ambiguity in method and attribute resolution.

2.    Multiple Inheritance (Through Interfaces):

·         Java supports multiple inheritance through interfaces. A class can implement multiple interfaces, effectively inheriting abstract method declarations from each interface.

·         However, Java does not support multiple inheritance of implementation (i.e., inheriting from multiple classes). This helps prevent the "diamond problem" and maintain code clarity.

3.    Multilevel Inheritance:

·         In multilevel inheritance, a class extends another class, which in turn extends yet another class. This creates a chain of inheritance relationships.

·         Java supports multilevel inheritance, and it allows you to create deep inheritance hierarchies.

4.    Hierarchical Inheritance:

·         Hierarchical inheritance involves multiple subclasses inheriting from a single superclass. This forms a tree-like structure.

·         Each subclass shares the properties and behaviors of the common superclass while adding its own unique characteristics.

5.    Hybrid Inheritance:

·         Hybrid inheritance combines different types of inheritance within a single program. It can involve a mix of single inheritance, multiple inheritance through interfaces, multilevel inheritance, and hierarchical inheritance.

·         Java allows hybrid inheritance but with certain restrictions and careful design considerations to avoid complications.

 

                                                                                                               (1 X 15 = 15 Marks)

Comments

Post a Comment