Why can't we instantiate a abstract class in J

问题:

I understand:

1. Since Abstract class are nothing on its own i.e. vehicle that's why we want to create an object of an concrete implementation like Car,Bike etc.

2. Constructor of an Abstract class gets called during object chaining.

3. We can never directly create an object of Abstract class even if it contains a Constructor and all methods are implemented

why ? I am looking to understand from Compiler perspective, why Java forces these ?

Thanks

回答1:

This is not a technical limitation, rather (as you have pointed out) a logical one. Java (and many other languages) enforce various rules not because they are impossible to break, but because this is an intentional part of the language.

回答2:

An abstract class is not complete! The author marked it abstract to tell you that some implementation is missing in the code. The author has done some of the work, but you must fill in some bits yourself to get it working. The abstract keyword ensures that no one would accidentally initiate this incomplete class.

Think of repairing a car. Someone has removed the brake pads and is going to replace them in the next day. Now, to prevent someone accidentally driving this car(which has no brakes installed), the mechanic installs a lock on the steering wheel. It's a fail-safe measure.

回答3:

rocketboy shows some mechanistic reasons, but there's a conceptual reason.

An Abstract class represents an abstract concept. Take your vehicle example. You cannot build a vehicle that is not something more specific. You can have a set of vehicles, that could be made of 2004 corolla's and '98 ford escorts and 1984 cs36 (a kind of yacht), a mark 4 firefly class mid-range bulk transport(the one with the stabilizers), you can take any one of those individually and call them a vehicle but you cannot have something that is only a vehicle and not one of those or some other specific type of vehicle.

Abstract classes represent such abstract concepts as vehicle. Hence the idea of instantiating one is non-sensical because to actually instantiate it you need to know what you're instantiating.

回答4:

An abstract classs can NOT be instantiated by using new operator. Becuase an abstract may have abstract methods i.e. methods without any body (or implementation). Because an object can NOT have an abstract methods and JVM can NOT allocate memory of the abstract methods

回答5:

Because an Abstract Class is a skeleton structure(an incomplete construct if you may), hence the term Abstract.

abstract class Person(){
   abstract void Speak();
}

Means every Person must speak. That means every person should know how to speak (implement the speak()). new Person() cannot have that, so it is not allowed.

回答6:

You can't instantiate an interface or an abstract class because it would defy the object oriented model. Read more

回答7:

What I understand that Abstract classes may contain abstract (empty without implementation) methods. If we instantiate an object and call the empty method, It's not going to work and may cause problem, hence compiler forces this RULE. any further in-sighter ?

回答8:

abstract it self tells : existing in thought or as an idea but not having a physical or concrete existence. In java term , abstract keyword definition , if abstract comes before a class name, then JDK tells to JVM about discard that class object initiation. It's correct, abstract class can have multiple constructor but only for constructor chaining.

回答9:

You can't instantiate abstract class because it's just to give a structure your class which is extending it.

And if you want to initiate your class, then why you want to define it as abstract?

回答10:

very simple reason jvm playing to restrict us to instantiate abstract class and interface.

Assume compiler allow us to instantiate both ok.

So suppose my abstract class contains 5 abstract method means only method prototype no method body.

So as we know every method call creating a separate stack in jvm Java stack area That memory allocation happened based on method structure and after execute that stack is destroying right.

So if my method is not contains any body means how can jvm predict memory to allocate that method

Second if no body means no method execution so never it will destroy from your Java stack area there may be a chance u can get memoryout error.

So to consider these 2 case compiler restrict us to instantiate both interface and abstract class

回答11:

Because Java restricted it that's why we can not instantiated the abstract class. Because in general scenario abstract means incomplete so we can not make of object of incomplete things.We have to provide the complete implementation of an abstract class in a concrete class. But we cannot create the object of an abstract class.

回答12:

Because an abstract class is an incomplete class (incomplete in the sense it contains abstract methods without body and output) we cannot create an instance or object; the same way you say for an interface.

回答13:

You CAN instantiate an abstract class. You only need to provide a concrete subclass.

回答14:

Well actually you can - but only if you implement any methods that have been declared abstract or left out.

/**
 * A classic adaptor pattern.
 *
 * @param <P>
 * @param <Q>
 */
public static interface Adapter<P, Q> {

  public Q adapt(P p);

}

/**
 * An I walks an iterator of one type but delivers items of a different type.
 *
 * Please fill in the `next()` method. Use an Adaptor for convenience.
 *
 * @param <S>
 * @param <T>
 */
public abstract static class I<S, T> implements Iterator<T> {

  protected final Iterator<S> it;

  public I(Iterator<S> it) {
    this.it = it;
  }

  @Override
  public boolean hasNext() {
    return it.hasNext();
  }

  @Override
  public void remove() {
    it.remove();
  }

}

/**
 * Use an adaptor to transform one type into another.
 *
 * @param <S>
 * @param <T>
 */
public static class IA<S, T> extends I<S, T> {

  private final Adapter<S, T> adaptor;

  public IA(Iterator<S> it, Adapter<S, T> adaptor) {
    super(it);
    this.adaptor = adaptor;
  }

  @Override
  public T next() {
    // Implement the abstract method on-the-fly.
    return adaptor.adapt(it.next());
  }

}

Added

The IA class instantiates an object of the I abstract class and implements the next method that was missing from the I class. You are actually creating an object of an anonymous that implements the implied abstract method.

回答15:

The reason why Java doesnt allows an abstract class to be instantiated is logical. We haven't given the definition of a method and therefore, if it had allowd the creation of the object, there was no return address to pop the function from the stack and we get thus, stuck. Thus, its logical only not to allow the object instattion.