What is the difference between inherit from an abstract class and from a concrete class? Why would we need the latter? - class

Question

I Know Abstract is a class something else extends on
but why would anything want to extend a non-abstract class?
Is it generally a better convention to only extend from abstract classes as then they cant be instantiated so it doesn't do weird stuff?
an example of both showing why one must be abstract/not abstract to show distinction would be awesome.

Answer 1

There are many situations where you would want to extend from concrete classes.
Consider a class called Device. Each device has a name and can be in three states, ON, OFF or INIT_STATE. Each device can be turned on or off.
public class Device {
private String name;
private static final int ON = 1;
private static final int OFF = 0;
private static final int DEVICE_INIT_STATE = -1;
private int deviceStatus = DEVICE_INIT_STATE;
public Device(String name) {
this.name = name;
}
public final void on() {
if (deviceStatus==OFF || deviceStatus==DEVICE_INIT_STATE) {
deviceStatus = ON;
System.out.println(getName() + " turned on");
} else {
System.out.println(getName()+" is already on");
}
}
public final void off() {
if (deviceStatus==ON) {
deviceStatus = OFF;
System.out.println(getName() + " turned off");
} else {
System.out.println(getName()+" is not on");
}
}
public void undo() {
if (deviceStatus==ON) {
off();
} else if(deviceStatus==OFF){
on();
}
}
public String getName() {
return name;
}
protected boolean isON() {
return deviceStatus==ON;
}
}
Consider a Stereo which is also a Device but has additional functionality such as openTray, closeTray and setCd and can be in 5 states that is ON, OFF, TRAY_OPEN, TRAY_CLOSE and INIT_STATE.
public class Stereo extends Device {
private String cd;
private static final int TRAY_OPEN = 1;
private static final int TRAY_CLOSE = 0;
private static final int TRAY_INIT_STATE = -1;
protected int trayState = TRAY_INIT_STATE;
public Stereo(String name) {
super(name);
}
public void openTray() {
if(!isON()) {
System.out.println(getName()+" is not on");
} else if(trayState==TRAY_CLOSE || trayState == TRAY_INIT_STATE) {
trayState = TRAY_OPEN;
System.out.println("Tray opened for "+getName());
} else {
System.out.println(getName()+" tray is already open");
}
}
public void closeTray() {
if(!isON()) {
System.out.println(getName()+" is not on");
} else if(trayState==TRAY_OPEN) {
trayState = TRAY_CLOSE;
System.out.println("Tray closed for "+getName());
} else {
System.out.println(getName()+" tray is not open");
}
}
public void undo() {
if(trayState==TRAY_OPEN) {
closeTray();
} else if(trayState==TRAY_CLOSE) {
openTray();
}
}
public void setCd(String cd) {
this.cd = cd;
}
public String getCd() {
return cd;
}
}
Stereo inherits the on and off methods from Device. You can instantiate a basic device such as a light bulb as follows :
Device lightBulb = new Device("Living room light bulb");
On the other hand, you could instantiate a Stereo as follows :
Stereo stereo = new Stereo("Stereo in my heart");
The take-away from the above example is that a light bulb is a basic Device that can only be turned on or off. A Stereo on the other hand is a more specialized kind of Device which can be turned on and off but also has openTray and closeTray functionality. Since Stereo is a Device, it inherits the on and off method from Device. This is an example where the super class has a use-case where it can be instantiated and does not need to be abstract.

Answer 2

You are talking about two orthogonal things imho.
In the former you want to ensure that no one can instantiate your abstract class. Plus give some additional goodies such as declare some common methods.
In inheritance you are extending a class to add / update some functionality.If you are parent class can be instantiated - you dont need to make it abstract.