Instantiate Java Abstract class?

Question

Relatively new Java programmer and I've been taught that you can't create an instance of an abstract class. I've also done a little research and I learned that in most cases when it appears an abstract class is being created, it is actually an anonymous subclass. But here is the issue I ran into:

Java's URL class has a method openConnection that returns a URLConnection. URLConnection is an abstract class, and the Java documentation also lists all of its subclasses as abstract..... so I'm really lost. What's being returned?

Answer 1

What is being returned is a non-abstract subclass that you won't find in the API documentation, for example sun.net.www.protocol.http.HttpUrlConnection. If you run the same code from an applet in a browser, you'll likely get a different one, usually something that wraps the browser's native connections.

So there's no trick and no magic there, just that some classes don't show up in the API docs as they're considered internal to the implementation and subject to change.

There are plenty of similar examples, DocumentBuilderFactory or TransformerFactory are both abstract but their newInstance() method will return a subclass, usually packaged separately (e.g. Saxon).

But there are also different solutions to the same problem: JDBC defines the Driver interface (rather than an abstract class), and a DriverManager utility class with static methods to load the different driver implementations. Instead of extending an abstract class, database driver vendors are required to implement the Driver interface.

By the way, to find the actual runtime class of the object, just call getClass() on them.

Answer 2

openConnection returns some concrete class which extendsURLConnection. The method's signature is defined as returning URLConnection since your code using it should not rely on any specific implementation.

Answer 3

Polymorphism concept will apply here.

The type of objects will be the URLConnection(Parent class\interface) and and object will be of its child class(extends or implements( in case of interface)).

Following example might make this thing clear to you.

abstract class URLConnection {
  // some methods. 
}

Let's suppose you have your own class.

class ConnectionClass extends URLConnection {
  // some methods 
} 

class Main {
  URLConnection connect = null

  public URLConnection getUrl() {
    return connect = new ConnectionClass();
  }
}

You will return object of class, who gives implementation of openConnection() of URLConnection class. Same concepts apply in interface case.

Answer 4

Could be Anonymous Class

Say you have an abstract class...

abstract class Vehicle {
    abstract public void move();
}

Without ever making a class Car extends Vehicle or class Boat extends Vehicle you can do this with the magic of Anonymous Classes. (Which may be why the javadoc does not say there is a subclass because it is anonymous and therefore cannot be referenced by the public api, which the javadoc represents.)

class Example {

    public Vehicle foo() {

        Vehicle car = new Vehicle {
            @Override
            public void move() {
                // do some car movement, i.e. driving
            }
        }

        return car;
    }

    public Vehicle bar() {

        Vehicle boat = new Vehicle {
            @Override
            public void move() {
                // do some boat movement, i.e. boating
            }
        }

        return boat;
    }
}

So no you can't instantiate an abstract class... but that's not really the whole truth, you can do it as an Anonymous Class and implement the methods on the spot. This technically is not instantiating an abstract class though, but it's what gets done a lot when you see this sort of thing.

---

Could be private Inner Class

Again, say you have an abstract class...

abstract class Vehicle {
    abstract public void move();
}

If the inner class was private then only the class that is encasing it could instantiate it. (Which may be why the javadoc does not say there is a subclass because it is private and therefore hidden from the public api, which the javadoc represents.)

class Example {

    private class Car extends Vehicle {
        @Override
        public void move() {
            // do some car movement, i.e. driving
        }
    }

    private class Boat extends Vehicle {
        @Override
        public void move() {
            // do some boat movement, i.e. boating
        }
    }

    public Vehicle foo() {
        return new Car();
    }

    public Vehicle bar() {
        return new Boat();
    }
}

This doesn't explain anything about instantiating abstract classes, but it may help answer about URL, openConnection, and URLConnection.

Answer 5

It's a class extending URLConnection that is being returned. It's a way of hiding implementation detail as different implementation of URLConnection can be returned depending on the input parameters.

Answer 6

When all subclasses are abstract, then it's because you can only use the classes by creating it in a factory. If you check carefully the code in Using java.net.URLConnection to fire and handle HTTP requests , you will see that URLConnection object is never instanced. Instead, we get it by calling openConnection like this:

URLConnection connection = new URL(url + "?" + query).openConnection();