A obj = new A("asasdfad");
System.out.println(obj); // → com.hitarth.oop.A@5f184fc6 // some random stuff is printed out
// we don't want this hash value to be printed but want the name and number to be printed out.
// for that we use @Override

class A {  
    final int num = 10;  
    String name;  
  
    A(String name)  
    {        
	    this.name = name;  
    }  
}
Copy

Internally, when we try to print obj the .toString method is called upon the object.

If the .toString method is NOT present in the object (see class A above, there is no .toString() method present there) then the default .toString method is called which looks like this :

Packages are basically containers for classes. It is used to keep the class names compartmentalized.
In simple terms, packages are just folders.
com.kunal means com/kunal i.e. kunal folder lives inside com folder

• Here we don't have to use import as both Human and Main classes are in the same folder

• As soon as a class is loaded, all the static elements are loaded first.

package com.hitarth.oop;

// this is a demo to show initialisation of static variables
public class StaticBlock {
    static int a =4;
    static int b;

    // static block: will get executed exactly once when the class is loaded
    static {
        System.out.println("I'm in a static block");
        b = a*5;
    }

    public static void main(String[] args) {
        StaticBlock obj = new StaticBlock();
        System.out.println(StaticBlock.a + " " + StaticBlock.b);
    }
}
Copy

• Output :

I'm in a static block
4 20
Copy

package com.hitarth.oop;

// this is a demo to show initialisation of static variables
public class StaticBlock {
    static int a =4;
    static int b;

    // static block: will get executed exactly once when the class is loaded
    static {
        System.out.println("I'm in a static block"); // → I'm in a static block
        b = a*5;
    }

    public static void main(String[] args) {
        StaticBlock obj = new StaticBlock();
        System.out.println(StaticBlock.a + " " + StaticBlock.b); // → 4 20

        StaticBlock.b +=3;

        StaticBlock obj2 = new StaticBlock();
        System.out.println(b); // → 23 // so when we created a new object it did not run the static block again, hence the static things are only run once when the first object is created. Even if we had not created objects "obj" and "obj2" we'd still be able to perform the same calculations.
    }
}
Copy

Class inside a class.
NOTE : Outside classes (The classes which are not inside any classes, for e.g. InnerClasses class in the code block below) can't be static.

• Therefore, outside classes can't be static, only inner classes can be static.
• This is because the outside class is itself not dependent on any other class, so how can you put it as static.
• Static methods are resolved during compile time, whereas objects are resolved during run time.

package com.hitarth.oop;

/* ------------------------------------------------------ */

// since this class is an outside class it needs not be a static class.
class TestOutside {
    static String text;

    public TestOutside(String text) {
        this.text = text;
    }
}

/* ------------------------------------------------------ */

public class InnerClasses {

    // this "Test" class is inside a class so, it can be static.
    // with static, this class is not dependent on the class outside, it does require an object of the container class to be created
    static class Test {
        String name;

        public Test(String name) {
            this.name = name;
        }
    }

    public static void main(String[] args) {

        //Test
        Test a = new Test("some name");
        Test b = new Test("changed name");
        System.out.println(a.name); // → some name
        System.out.println(b.name); // → changed name

        //TestOutside
        TestOutside random = new TestOutside("alkasdd");
        TestOutside random_2 = new TestOutside("jhgfa");
        System.out.println(random.text); // → jhgfa
        System.out.println(random_2.text); // → jhgfa
        // hence the same static variable was changed
    }
}
Copy

• When you want ONLY 1 instance of a class to be created, you'll use singleton classes.
  

Above code in text format : (Both files are in the same folder)

Main.java :

package com.hitarth.oop;

public class Main {

    public static void main(String[] args) {
        Singleton obj = Singleton.getInstance();
        Singleton obj2 = Singleton.getInstance();
        Singleton obj3 = Singleton.getInstance();
        // so, every time someone asks for a new instance we are giving it the same instance again and again, hence no more than 1 instance is being created.
        // therefore all 3 ref variables are pointing to just one object
        // since the constructor is private therefore we can't call a constructor here either, hence we can't create more than 1 objects
    }
}
Copy

Singleton.java :

package com.hitarth.oop;

public class Singleton {

    // constructor
    private Singleton() {
        // private class is basically a class only accessible to this file
        // whatever thing is private will only run in this class
    }

    // since this instance is not going to be dependent on the class "SingletonClass", we aren't going to create an object of that outside class right, it is not allowed, so we are only going to be returning the "instance" object created below, so we can put it as static.

    private static Singleton instance;

    public static Singleton getInstance() {
        // first, check whether 1 obj only is created or not
        // instance == null will be true if no object had been created, i.e. reference variable will be null and will not be assigned to any pointer.
        if (instance == null) {
            // if no object had been created, we'll make one
            instance = new Singleton(); // constructor can be called here since it is in the same file
        }
        return instance;
    }

}
Copy