What is Java Classloader ?

It is a part of the JRE that dynamically loads Java classes into the JVM, The class loader is responsible for locating libraries, reading their contents, and loading the classes contained within the libraries,

When the JVM is started, three class loaders are used:

    The bootstrap class loader loads the core Java libraries located in the <JAVA_HOME>/jre/lib directory. This class loader, which is part of the core JVM, is written in native code.

     The extensions class loader loads the code in the extensions directories (<JAVA_HOME>/jre/lib/ext, or any other directory specified by the java.ext.dirs system property). It is implemented by the sun.misc.Launcher$ExtClassLoader class.

     The system class loader loads code found on java.class.path, which maps to the CLASSPATH environment variable. This is implemented by the sun.misc.Launcher$AppClassLoader class.

What is Singleton Class ?

Singleton Class

The Singleton's purpose is to control object creation, limiting the number to one but allowing the flexibility to create more objects if the situation changes.

Since there is only one Singleton instance, any instance fields of a Singleton will occur only once per class, just like static fields. Singletons often control access to resources such as database connections or sockets. For example, if you have a license for only one connection for your database or your JDBC driver has trouble with multithreading, the Singleton makes sure that only one connection is made or that only one thread can access the connection at a time.

Implementing Singletons:

The easiest implementation consists of a private constructor and a field to hold its result, and a static accessor method with a name like getInstance().

The private field can be assigned from within a static initializer block or, more simply, using an initializer. The getInstance( ) method (which must be public) then simply returns this instance:

// File Name: Singleton.java

public class Singleton {

   private static Singleton singleton = new Singleton( );

   /* A private Constructor prevents any other class from instantiating.   */

   private Singleton(){ }

      /* Static 'instance' method */

   public static Singleton getInstance( ) {

      return singleton;

   }

   /* Other methods protected by singleton-ness */

   protected static void demoMethod( ) {

      System.out.println("demoMethod for singleton");

   }

}

// File Name: SingletonDemo.java

public class SingletonDemo {

   public static void main(String[] args) {

      Singleton tmp = Singleton.getInstance( );

      tmp.demoMethod( );

   }

}

This would produce following result:

demoMethod for singleton

What are different types of inner classes?

Nested top-level classes- If you declare a class within a class and specify the static modifier, the compiler treats the class just like any other top-level class.
Any class outside the declaring class accesses the nested class with the declaring class name acting similarly to a package. e.g., outer.Inner. Top-level inner classes implicitly have access only to static variables. There can also be inner interfaces. All of these are of the nested top-level variety.

Member classes - Member inner classes are just like other member methods and member variables and access to the member class is restricted, just like methods and variables. This means public member class acts similarly to a nested top-level class. The primary difference between member classes and nested top-level classes is that member classes have access to the specific instance of the enclosing class.

Local classes - Local classes are like local variables, specific to a block of code. Their visibility is only within the block of their declaration. In order for the class to be useful beyond the declaration block, it would need to implement a
more publicly available interface. Because local classes are not members, the modifiers public, protected, private, and static are not usable.
Anonymous classes - Anonymous inner classes extend local inner classes one level further. As anonymous classes have no name, you cannot provide a constructor.