I understand:
But from the compiler's perspective, why does Java enforce these rules?
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.
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.
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.
An abstract class can't be instantiated by using new operator. Because an abstract class may have abstract methods i.e. methods without any implementation. Because an object can't have abstract methods, JVM can't allocate memory of these objects abstract methods
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.
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.
You can't instantiate an interface or an abstract class because it would defy the object oriented model. Read more
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 ?
You CAN instantiate an abstract class. You only need to provide a concrete subclass.
In java, everything is represented as an object except a few cases. When you are about to instantiate the class (A blueprint), you must know the exact size of the class member variables, member methods, and the constructors. Since some/all of the methods are abstract, and JVM doesn't know the size. Hence allocating memory is useless.
But We can implement something to overcome this problem If we take the memory allocation part away from the JVM and assign this ownership to the USER.
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?
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.
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
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.
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());
}
}
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.
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.
