Introduction

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of objects, which contain data and methods. Java is a purely object-oriented language (except for primitive types) and supports OOP concepts such as classes, objects, constructors, inheritance, polymorphism, encapsulation, and abstraction. This lab focuses on understanding fundamental OOP concepts through practical Java programs.

Objectives

The objectives of this lab are:

To understand the basic concept of class and object in Java
To demonstrate the use of the this keyword in Java programs
To understand and implement parameterized constructors
To demonstrate the concept of a copy constructor in Java
To understand the concept of passing by value in Java
To implement and understand method overloading
To demonstrate the working of a nested inner class
To understand the concept of an anonymous inner class
To implement recursion by finding the factorial of a number

Program 1: Demonstrate Class and Object

ClassObjectDemo.java

class Student {
    int id;
    String name;

    void display() {
        System.out.println("ID: " + id);
        System.out.println("Name: " + name);
    }
}

public class ClassObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.id = 29;
        s1.name = "Prakash";

        s1.display();
    }
}

Output:

Program 2: Demonstrate `this` Keyword

ThisKeywordDemo.java

class Person {
    int age;

    Person(int age) {
        this.age = age;
    }

    void display() {
        System.out.println("Age: " + age);
    }
}

public class ThisKeywordDemo {
    public static void main(String[] args) {
        Person p = new Person(21);
        p.display();
    }
}

Output:

Program 3: Demonstrate Parameterized Constructor

ParameterizedConstructorDemo.java


class Employee {
    int id;
    String name;

    Employee(int i, String n) {
        id = i;
        name = n;
    }

    void display() {
        System.out.println("Id: "+id + " Name: " + name);
    }
}

public class ParameterizedConstructorDemo {
    public static void main(String[] args) {
        Employee e1 = new Employee(29, "Prakash");
        e1.display();
    }
}

Output:

Program 4: Demonstrate Copy Constructor

CopyConstructorDemo.java

class Book {
    String title;

    Book(String t) {
        title = t;
    }

    Book(Book b) {
        title = b.title;
    }

    void display() {
        System.out.println("Title: " + title);
    }
}

public class CopyConstructorDemo {
    public static void main(String[] args) {
        Book b1 = new Book("Java Programming");
        Book b2 = new Book(b1);

        b1.display();
        b2.display();
    }
}

Output:

Program 5: Demonstrate Passing by Value

PassByValueDemo.java

public class PassByValueDemo {

    static void change(int x) {
        x = 2;
    }

    public static void main(String[] args) {
        int num = 9;
        change(num);
        System.out.println("Value of num: " + num);
    }
}

Output:

Program 6: Demonstrate Method Overloading

MethodOverloadingDemo.java

class Calculator {

    int add(int a, int b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class MethodOverloadingDemo {
    public static void main(String[] args) {
        Calculator c = new Calculator();
        System.out.println("Sum before: " +c.add(2, 9));
        System.out.println("Sum after: " +c.add(2, 9, 11));
    }
}

Output:

Program 7: Demonstrate Nested Inner Class

NestedInnerClassDemo.java

class Outer {
    int x = 2;

    class Inner {
        void show() {
            System.out.println("Value of x: " + x);
        }
    }
}

public class NestedInnerClassDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        Outer.Inner i = o.new Inner();
        i.show();
    }
}

Output:

Program 8: Demonstrate Anonymous Inner Class

AnonymousInnerClassDemo.java

abstract class Demo {
    abstract void display();
}

public class AnonymousInnerClassDemo {
    public static void main(String[] args) {
        Demo d = new Demo() {
            void display() {
                System.out.println("Anonymous Inner Class Example");
            }
        };
        d.display();
    }
}

Output:

Program 9: Demonstrate Class and Object

ClassObjectDemo2.java

class Car {
    String model;

    void show() {
        System.out.println("Car Model: " + model);
    }
}

public class ClassObjectDemo2 {
    public static void main(String[] args) {
        Car c = new Car();
        c.model = "Porsche 911 GT3 RS";
        c.show();
    }
}

Output:

Program 10: Recursive Program to Find Factorial

FactorialRecursion.java

public class FactorialRecursion {

    static int factorial(int n) {
        if (n == 0)
            return 1;
        else
            return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        int num = 5;
        System.out.println("Factorial of " + num + " is " + factorial(num));
    }
}

Output:

Conclusion

In this lab, we studied the core concepts of Object-Oriented Programming in Java. We learned how to create classes and objects, use constructors, apply the this keyword, implement copy constructors, understand passing by value, perform method overloading, work with inner classes, and apply recursion. These concepts form the foundation of object-oriented application development in Java.