Introduction

Inheritance is one of the core concepts of Object-Oriented Programming that allows a class to acquire the properties and methods of another class. Java supports inheritance using the extends keyword and provides important features such as method overriding, abstract classes, interfaces, and the super keyword. Packaging helps organize classes into namespaces, improving modularity and code reuse. This lab demonstrates these concepts through practical Java programs.

Objectives

The objectives of this lab are:

To understand the concept of abstract class and abstract method
To demonstrate the use of static variables and constructors
To understand and implement the super keyword
To demonstrate method overriding in Java
To understand and implement interfaces
To demonstrate the use of final variable, final method, and final class
To understand the concept of built-in packages and user-defined packages

Program 1: Abstract Class and Abstract Method

AbstractDemo.java

abstract class Shape {
    abstract void draw();
}

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

public class AbstractDemo {
    public static void main(String[] args) {
        Shape s = new Circle();
        s.draw();
    }
}

Output:

Program 2: Static Variable and Constructor

StaticVariableDemo.java

class Counter {
    static int count = 0;

    Counter() {
        count++;
    }

    static void displayCount() {
        System.out.println("Object count: " + count);
    }
}

public class StaticVariableDemo {
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();

        Counter.displayCount();
    }
}

Output:

Program 3: Demonstrate `super` Keyword

SuperKeywordDemo.java

class Animal {
    String name = "Animal";

    Animal() {
        System.out.println("Animal constructor called");
    }
}

class Dog extends Animal {
    String name = "Dog";

    Dog() {
        super();
        System.out.println("Dog constructor called");
    }

    void display() {
        System.out.println("Parent name: " + super.name);
        System.out.println("Child name: " + name);
    }
}

public class SuperKeywordDemo {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.display();
    }
}

Output:

Program 4: Method Overriding

MethodOverridingDemo.java

class Bank {
    int getRateOfInterest() {
        return 3;
    }
}

class NabilBank extends Bank {
    int getRateOfInterest() {
        return 4;
    }
}

public class MethodOverridingDemo {
    public static void main(String[] args) {
        Bank b = new NabilBank();
        System.out.println("Rate of Interest: " + b.getRateOfInterest());
    }
}

Output:

Program 5: Interface

InterfaceDemo.java

package labReports.lab4;
import java.util.Scanner;

interface A{
    public void sum(int a) ;
}

interface B{
    public void check(int x) ;
}

public class InterfaceDemo  implements labReports.lab4.A, labReports.lab4.B {

    //find sum upto the entered integer
    public void sum(int b){
        int sum=0;
        for (int i=0; i<=b; i++){
            sum+=i;
        }

        System.out.println("Sum of natural numbers upto "+b+" is: "+sum);
    }
    //check if the entered integer is even or odd
    public void check(int a){
        if(a%2==0){
            System.out.println(a+" is Even");
        } else{
            System.out.println(a+" is Odd");
        }
    }

    public static void main(String[] args){
        labReports.lab4.InterfaceDemo interfaceDemo = new labReports.lab4.InterfaceDemo();
        Scanner sc = new Scanner(System.in);

        System.out.println("Enter an integer to find sum and check if even or odd");
        int n=sc.nextInt();

        interfaceDemo.sum(n);
        interfaceDemo.check(n);
    }
}

Output:

Program 6: Final Variable, Final Method, and Final Class

FinalDemo.java

final class FinalClass {
    final int value = 11;

    final void display() {
        System.out.println("Final value: " + value);
    }
}

public class FinalDemo {
    public static void main(String[] args) {
        FinalClass f = new FinalClass();
        f.display();
    }
}

Output:

Program 7: Built-in Package and User-Defined Package

BuiltInPackageDemo.java

Built-in Package Example:

import java.util.Scanner;

public class BuiltInPackageDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter name: ");
        String name = sc.nextLine();
        System.out.println("Hello " + name);
        sc.close();
    }
}

Output:

User-Defined Package Example:

MyClass.java

package labReports.lab4.myPackage; //folder myPackage 

public class MyClass {
    public void show() {
        System.out.println("User Defined Package Example");
    }
}

TestPackage.java

package labReports.lab4.myPackage; 

public class TestPackage {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.show();
    }
}

Output:

Conclusion

In this lab, we learned important concepts of inheritance and packaging in Java. We explored abstract classes, static variables, the super keyword, method overriding, interfaces, and the use of final variables, methods, and classes. We also understood how built-in and user-defined packages help organize Java programs. These concepts are essential for building reusable and maintainable object-oriented applications.