What is the difference between Class forName and Class forName newInstance

Question

What is the difference between Class forName   and Class forName   newInstance     I do not understand the significant difference  I have read something about them    Could you please help me

User · Accepted Answer

Maybe an example demonstrating how both methods are used will help you to understand things better. So, consider the following class:

package test;

public class Demo {

    public Demo() {
        System.out.println("Hi!");
    }

    public static void main(String[] args) throws Exception {
        Class clazz = Class.forName("test.Demo");
        Demo demo = (Demo) clazz.newInstance();
    }
}

As explained in its javadoc, calling Class.forName(String) returns the Class object associated with the class or interface with the given string name i.e. it returns test.Demo.class which is affected to the clazz variable of type Class.

Then, calling clazz.newInstance() creates a new instance of the class represented by this Class object. The class is instantiated as if by a new expression with an empty argument list. In other words, this is here actually equivalent to a new Demo() and returns a new instance of Demo.

And running this Demo class thus prints the following output:

Hi!

The big difference with the traditional new is that newInstance allows to instantiate a class that you don't know until runtime, making your code more dynamic.

A typical example is the JDBC API which loads, at runtime, the exact driver required to perform the work. EJBs containers, Servlet containers are other good examples: they use dynamic runtime loading to load and create components they don't know anything before the runtime.

Actually, if you want to go further, have a look at Ted Neward paper Understanding Class.forName() that I was paraphrasing in the paragraph just above.

EDIT (answering a question from the OP posted as comment): The case of JDBC drivers is a bit special. As explained in the DriverManager chapter of Getting Started with the JDBC API:

(...) A Driver class is loaded, and therefore automatically registered with the DriverManager, in one of two ways:
by calling the method Class.forName. This explicitly loads the driver class. Since it does not depend on any external setup, this way of loading a driver is the recommended one for using the DriverManager framework. The following code loads the class acme.db.Driver:
Class.forName("acme.db.Driver");
If acme.db.Driver has been written so that loading it causes an instance to be created and also calls DriverManager.registerDriver with that instance as the parameter (as it should do), then it is in the DriverManager's list of drivers and available for creating a connection.
(...)
In both of these cases, it is the responsibility of the newly-loaded Driver class to register itself by calling DriverManager.registerDriver. As mentioned, this should be done automatically when the class is loaded.

To register themselves during initialization, JDBC driver typically use a static initialization block like this:

package acme.db;

public class Driver {

    static {
        java.sql.DriverManager.registerDriver(new Driver());
    }

    ...
}

Calling Class.forName("acme.db.Driver") causes the initialization of the acme.db.Driver class and thus the execution of the static initialization block. And Class.forName("acme.db.Driver") will indeed "create" an instance but this is just a consequence of how (good) JDBC Driver are implemented.

As a side note, I'd mention that all this is not required anymore with JDBC 4.0(added as a default package since Java 7) and the new auto-loading feature of JDBC 4.0 drivers. See JDBC 4.0 enhancements in Java SE 6.

User · Answer

Class forName   gives you the class object  which is useful for reflection  The methods that this object has are defined by Java  not by the programmer writing the class  They are the same for every class  Calling newInstance   on that gives you an instance of that class  i e  calling Class forName  ExampleClass   newInstance   it is equivalent to calling new ExampleClass     on which you can call the methods that the class defines  access the visible fields etc

User · Answer

Class forName   gets a reference to a Class  Class forName   newInstance   tries to use the no-arg constructor for the Class to return a new instance

User · Answer

just adding to above answers  when we have a static code  ie code block is instance independent  that needs to be present in memory  we can have the class returned so we ll use Class forname  someName   else if we dont have static code we can go for Class forname   newInstance  someName   as it will load object level code blocks non static  to memory

User · Answer

1   if you are interested only in the static block of the class   the loading the class only would do   and would execute static blocks then all you need is   Class forName  Somthing      2   if you are interested in loading the class   execute its static blocks and also want to access its its non static part   then you need an instance and then you need   Class forName  Somthing   newInstance

User · Answer

Class forName  -- gt forName   is the static method of Class class it returns Class class object used for reflection not user class object so you can only call Class class methods on it like getMethods    getConstructors   etc  If you care about only running static block of your Runtime given  class and only getting information of methods constructors Modifier etc of your class you can do with this object which you get using Class forName   But if you want to access or call your class method  class which you have given at runtime  then you need to have its object so newInstance method of Class class do it for you It create new instance of the class and return it to you  You just need to type-cast it to your class  ex-   suppose Employee is your class then Class a Class forName args 0        args 0  cmd line argument to give class at  runtime    Employee ob1 a newInstance     a newInstance   is similar to creating object using new Employee    now you can access all your class visible fields and methods

User · Answer

In JDBC world  the normal practice  according the JDBC API  is that you use Class forName   to load a JDBC driver  The JDBC driver should namely register itself in DriverManager inside a static block   package com dbvendor jdbc   import java sql Driver  import java sql DriverManager   public class MyDriver implements Driver        static           DriverManager registerDriver new MyDriver                public MyDriver                           Invoking Class forName   will execute all static initializers  This way the DriverManager can find the associated driver among the registered drivers by connection URL during getConnection   which roughly look like follows   public static Connection getConnection String url  throws SQLException       for  Driver driver   registeredDrivers            if  driver acceptsURL url                 return driver connect url                       throw new SQLException  No suitable driver        But there were also buggy JDBC drivers  starting with the org gjt mm mysql Driver as well known example  which incorrectly registers itself inside the Constructor instead of a static block   package com dbvendor jdbc   import java sql Driver  import java sql DriverManager   public class BadDriver implements Driver        public BadDriver             DriverManager registerDriver this              The only way to get it to work dynamically is to call newInstance   afterwards  Otherwise you will face at first sight unexplainable  SQLException  no suitable driver   Once again  this is a bug in the JDBC driver  not in your own code  Nowadays  no one JDBC driver should contain this bug  So you can  and should  leave the newInstance   away

User · Answer

No matter how many times you call Class forName   method  Only once the static block gets executed not multiple time  package forNameMethodDemo   public class MainClass        public static void main String   args  throws Exception           Class forName  quot forNameMethodDemo DemoClass quot            Class forName  quot forNameMethodDemo DemoClass quot            Class forName  quot forNameMethodDemo DemoClass quot            DemoClass demoClass    DemoClass Class forName  quot forNameMethodDemo DemoClass quot   newInstance              public class DemoClass            static           System out println  quot in Static block quot                         System out println  quot in Instance block quot             output will be  in Static block in Instance block  This in Static block statement is printed only once not three times

User · Answer

Class forName    returns the Class-Type for the given name   newInstance    does return an instance of this class   On the type you can t call directly any instance methods but can only use reflection for the class  If you want to work with an object of the class you have to create an instance of it  same as calling  new MyClass       Example for  Class forName     Class myClass   Class forName  test MyClass    System out println  Number of public methods      myClass getMethods   length     Example for  Class forName   newInstance     MyClass myClass    MyClass  Class forName  test MyClass   newInstance    System out println  String representation of MyClass instance      myClass toString

[java] What is the difference between "Class.forName()" and "Class.forName().newInstance()"?

Examples related to java

Examples related to class

Examples related to object

Examples related to instantiation