oops.java

// Learning OOPs concepts in Java

// OOPs stands for Object-Oriented Programming System. It is a programming paradigm that uses objects and classes to design and develop applications. The main concepts of OOPs are:

// ==================================================
// 1️⃣ CLASSES & OBJECTS, //attributes 
// ==================================================
// 1. classes & objects:-  class is a blueprint from which individual objects are created and an object is an instance of a class. It is a real-world entity that has state and behavior.
// For example, a car can be an object of the class "Vehicle" which has properties like color, model, and methods like start() and stop().

//class → defines actions ; object → calls those actions

//creating class with obj
class Dog {

    // Declaring and initializing the attributes
    String breed; // String breed = "German Shepherd";
    int age; // or int age = 2; to modify-> obj.age = 3;
    String color;
    final String name = "Tommy"; // cant modify

    // methods to set breed, age, and color of the dog
    void setBreed(String breed) {
        this.breed = breed;
    }

    void setAge(int age) {
        this.age = age;
    }

    void setColor(String color) {
        this.color = color;
    }

    // method to print all three values
    void printDetails() {
        System.out.println("Dog details:");
        System.out.println(this.breed);
        System.out.println(this.age);
        System.out.println(this.color);
    }
}

public class oops {

    public static void main(String[] args) {

        // Syntax to Create a Java Object - Class_name object_name = new Class_name([parameters]);

        // Creating an object of the class Dog
        Dog obj = new Dog();

        // setting the attributes
        obj.setBreed("Golden Retrives");
        obj.setAge(2);
        obj.setColor("Golden");

        obj.printDetails();
    }
}


// ✨ Instance variables and methods belong to objects, so we access them using the object name and dot operator.
// set to set it, get to print from it, & if directly want -> Access Variable directly= objectName.variableName
class Puppy {

    int puppyAge;

    public Puppy(String name) {
        // This constructor has one parameter, <i>name</i>.
        System.out.println("Name chosen is :" + name);
    }

    public void setAge(int age) {
        puppyAge = age;
    }

    public int getAge() {
        System.out.println("Puppy's age is :" + puppyAge);
        return puppyAge;
    }

    public static void main(String[] args) {

        /* Object creation */
        Puppy myPuppy = new Puppy("tommy");

        /* Call class method to set puppy's age */
        myPuppy.setAge(2);

        /* Call another class method to get puppy's age */
        myPuppy.getAge();

        /* You can access instance variable as follows as well */
        System.out.println("Variable Value :" + myPuppy.puppyAge);
    }
}


//example to demonstrate how to define class method and how to access it
//✨ Define method inside class → create object → call method using object.method().
class Cat {

    // class method
    void meow() {
        System.out.println("Cat is meowing");
    }

    public static void main(String[] args) {

        // create object
        Cat c = new Cat();

        // access the class method using object
        c.meow();
    }
}


// ==================================================
// ✳️ METHODS 
// ==================================================

// A Java method is a block of code inside a class that performs a specific task and runs when it is called. 🚀

//Syntax to Create a Java Method-> modifier returnType nameOfMethod (Parameter List) {//}
//ex  Defining and Calling a Java Method
class ExampleMinNumber {

    public static void main(String[] args) {
        int a = 11;
        int b = 6;
        int c = minFunction(a, b);
        System.out.println("Minimum Value = " + c);
    }

    public static int minFunction(int n1, int n2) {
        int min;

        if (n1 > n2)
            min = n2;
        else
            min = n1;

        return min;
    }
}


//1. The void Keyword with Java Methods
class ExampleVoid {

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

    public static void methodRankPoints(double points) {
        if (points >= 202.5) {
            System.out.println("Rank:A1");
        } else if (points >= 122.4) {
            System.out.println("Rank:A2");
        } else {
            System.out.println("Rank:A3");
        }
    }
}


//2. Passing Parameters by Value in Java Methods
//Definition: Passing by value means a copy of the argument value is passed to the method, so the original variable remains unchanged.
//Example: swapFunction(a, b);

//3. Java Methods Overloading
//Definition: Method overloading means multiple methods having the same name but different parameter types or numbers.
//Example: minFunction(int n1, int n2) and minFunction(double n1, double n2)

//*// variable scope as “where a variable can be used and how long it lives.” 🌱
//| Type         | Declared                   | Lifetime            | Access                 |
//| ------------ | -------------------------- | ------------------- | ---------------------- |
//| **Instance** | Inside class               | Until object exists | `object.variable`      |
//| **Static**   | Inside class with `static` | Whole program       | `ClassName.variable`   |
//| **Local**    | Inside method              | Until method ends   | Only inside that block |


// ==================================================
// ✳️ CONSTRUCTORS
// ==================================================

// const name should be same as cls name, no return type
// syx - class ClassName {ClassName() {  }}
// types -> 1. Default Constructor (A Class Without Any Constructor)

//2. No-Args Constructor
class Main {
  int num1;
  int num2;

  // Creating no-args constructor
  Main() {
    num1 = -1;
    num2 = -1;
  }

  public static void main(String[] args) {
    // no-args constructor will invoke
    Main obj_x = new Main();

    // Printing the values
    System.out.println("num1 : " + obj_x.num1);
    System.out.println("num2 : " + obj_x.num2);
  }
}

//3.  Parameterized Constructor
 class Mainn {
  int num1;
  int num2;

  // Creating parameterized constructor 
  Mainn(int a, int b) {
    num1 = a;
    num2 = b;
  }

  public static void main(String[] args) {
    // Creating two objects by passing the values 
    // to initialize the attributes.
    // parameterized constructor will invoke
    Mainn obj_x = new Mainn(10, 20);
    Mainn obj_y = new Mainn(100, 200);

    // Printing the objects values
    System.out.println("obj_x");
    System.out.println("num1 : " + obj_x.num1);
    System.out.println("num2 : " + obj_x.num2);

    System.out.println("obj_y");
    System.out.println("num1 : " + obj_y.num1);
    System.out.println("num2 : " + obj_y.num2);
  }
}


// ==================================================
// ✳️ ACCESS MODIFIERS
// ==================================================
// decide who can see or use a variable, method, class, or constructor. 🔐

// ==================================================
// ✳️ INHERITANCE
// ==================================================

// ✨ Inheritance lets a child class reuse and extend the features of a parent class using extends

// Parent class
class Animal{

    String name;

    //Constructor
    Animal(String name){
        this.name = name;
    }

    //Parent method
    void eat(){
        System.out.println(name + " is eating");
    }

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

// Child class
class crow extends Animal {
    crow(String name){
        super(name);// calls parent constructor
    }

    //New method (child feature)
    void run(){
        System.out.println(name + " is running");
    }

    //Method overriding
    void sound(){
        System.out.println(name + " croo");
    }

}

//Main class
/*public*/ class Mian{
    public static void main(String[] args){

        //Creating child object
        crow c = new crow("kowa");

        // Inherited method from parent
        c.eat();

        // Overridden method
        c.sound();

        // Child method
        c.run();

    }
}


// ==================================================
// ✳️ AGGREGATION
// ==================================================

class Address {
    String city;
    String state;

    Address(String city, String state){
        this.city = city;
        this.state = state;
    }
}

class Student {
    int rollNo;
    String name;
    Address address;   // Aggregation happens here

    Student(int rollNo, String name, Address address) {
        this.rollNo = rollNo;
        this.name = name;
        this.address = address;
    }

    void display() {
        System.out.println(rollNo + " " + name);
        System.out.println(address.city + " " + address.state);
    }
}

/* public class Main {
    public static void main(String[] args) {

        Address ad = new Address("Hyderabad", "Telangana");

        Student s = new Student(101, "Riya", ad);

        s.display();
    }
}*/

// ==================================================
// ✳️ POLYMORPHISM- Overloading , Overriding
// ==================================================
//Method Overloading (same method name, different parameters)
//Method Overriding (child changes parent method)
//Polymorphism (parent reference → child object)

class Animall {
    // Method (will be overridden)
    void sound(){
        System.out.println("Animal makes a sound");
    }
    // Method Overloading
    void eat(){
        System.out.println("Animal is eating");
    }
    void eat(String food){
        System.out.println("Animal eats" + food);
    }
}

class Lion extends Animall {
    // Method Overriding
    void sound(){
        System.out.println("Lion roars");
    }
}

// public class Main {

//     public static void main(String[] args) {

//         // Polymorphism
//         Animal a = new Dog();

//         // Overriding happens here
//         a.sound();

//         // Overloading examples
//         a.eat();
//         a.eat("meat");
//     }
// }


// ==================================================
// ✳️ ABSTRACTION & Encapsulation
// ==================================================

//You see only the important part, not the complex internal process. hides implementation details and shows only functionality.
abstract class Aniimal {

    // Encapsulation (private variables)
    private String name;
    private int age;

    // Setter methods
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // Getter methods
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // Abstract method (Abstraction)
    abstract void makeSound();
}

class Doog extends Aniimal {

    // Implementing abstract method
    void makeSound() {
        System.out.println("Dog barks 🐶");
    }
}

// public class Main {
//     public static void main(String[] args) {

//         Dog d = new Dog();

//         d.setName("Rocky");
//         d.setAge(3);

//         System.out.println("Dog Name: " + d.getName());
//         System.out.println("Dog Age: " + d.getAge());

//         d.makeSound();
//     }
// }