Static VS Instance

• Static keyword in Java is used for memory management.

  • used for keeping the same copy of variables or methods for every instance of a class

  • If a member of a class is static, it can be accessed before any objects are created for that class and also without any object reference.

Static vs Non-Static variables

• If a field has the same value for all instances, it should be static

  • beacuse its a wastage of memory as for each object created it would allocate memory for that field variable for each of the instances created and further assign the given value in it.

• As a static variable, it would independent of the no. of instances created thereby saving memory.

Static vs Non-Static Methods

• Static methods are utility methods in a class which can be exposed to other classes without having to create an instance of the owner class to call the method.

• static methods are less memory intensive compared to non-static methods

• a non-static method is an instance-based method that needs to be called by specific instances of the class and the behavior of such methods completely depends on the state of the objects which calls them.

• Also used for factory methods

• Difference

  • Access

    • A static method can access only static members and can not access non-static members.

    • A non-static method can access both static as well as non-static members.

  • Binding

    • Static method uses complie time binding or early binding.

    • Non-static method uses run time binding or dynamic binding.

  • Overriding

    • A static method cannot be overridden being compile time binding.

    • A non-static method can be overridden being dynamic binding.

  • Memory allocation

    • Static method occupies less space and memory allocation happens once.

    • A non-static method may occupy more space. Memory allocation happens when method is invoked and memory is deallocated once method is executed completely.

  • Keyword

    • A static method is declared using static keyword.

    • A normal method is not required to have any special keyword.

Static Initialization block vs initialization block

• a block is a set of statements enclosed within curly braces which are used as a compound statement or a single unit of code.

• used in Methods, if-else statements, loops, and lambdas,

• blocks which are not used by other Java constructs are Independent blocks

  • are broad of two types namely

    • static initializer blocks

      • static keyword is used to define a static initialization block.

      • gets loaded as soon as a class gets loaded in the memory and is not associated with a call to the constructor of a class during object creation.

      • can only access static members of its class i.e. static variables and static methods.

      • The superclass constructor is not called automatically from the static initialization block.

      • called just once during the entire execution of the program when the class loads.

      • even called before the main method.

    • initializer blocks

      • An instance initialization block can be defined without using any special keyword.

      • only executed when there is a call to the constructor during object creation.

      • can both static as well as non-static members of its class i.e. static and non-static variables and methods.

      • An automatic call to super class constructor is made by using the super() before executing any statement in the instance initialization block.

      • called as many times as a call to the constructor of the class is made.

Static Inner class vs Inner class

• Nested classes class inside another class

• two types

  • static and non-static

  • Non-static nested classes are called inner classes.

• A nested class is a member of its enclosing class.

• Non-static nested classes (inner classes) have access to other members of the enclosing class, even if they are declared private

• Static nested classes do not have access to other members of the enclosing class.

• As a member of the OuterClass, a nested class can be declared private, public, protected, or package-private

  • outer classes can only be declared public or package-private

• Why Use Nested Classes?

  • It is a way of logically grouping classes that are only used in one place

  • It increases encapsulation

    • Only outer class can use it

  • It can lead to more readable and maintainable code

    • places the code closer to where it is used.

• a static nested class cannot refer directly to instance variables or methods defined in its enclosing class: it can use them only through an object reference.

• a static nested class is behaviorally a top-level class that has been nested in another top-level class for packaging convenience.

• an inner class is associated with an instance of its enclosing class and has direct access to that object’s methods and fields.

  • because an inner class is associated with an instance, it cannot define any static members itself.

• An instance of InnerClass can exist only within an instance of OuterClass and has direct access to the methods and fields of its enclosing instance.

• To instantiate an inner class, you must first instantiate the outer class. Then, create the inner object within the outer object

  • OuterClass.InnerClass innerObject = outerObject.new InnerClass();

• As main() method can’t be declared, regular inner class can’t be invoked directly from the command prompt.

• As main() method can be declared, the static nested class can be invoked directly from the command prompt.