A little question about inheritance

Question

Can someone explain this to me?
I have been reading about inheritance in Java. As I understand it when you extend a class, every method gets "copied" to the subclass. If this is so, how come this doesn't work?
class inherit {
    int number;
    public inherit(){
        number = 0;
    public inherit(int n){
        number = n;
class inherit2 extends inherit{
    public inherit2(int n, int p){
        number = n*p;
class example{
    public static void main(String args[]){
        inherit2 obj = new inherit2();
}What I try to do here is to extend the class inherit with inherit2. Now the obj Object is of inherit2 class and as such, it should inherit the constructor without parameters in the inherit class or shouldn't it ??? If not, then should I rewrite all the constructors which are the same and then add the new ones??

Answer 1

I believe you were asking why SubClass doesn't have the "default" constructor... after all, shouldn't SubClass just have all the contents of SuperClass copy-pasted into it? Not exacly. ;)
(code below... if you'd like, you can skip the first bit, start at the code, and work your way down... depending on if you just started, the next bit may confuse rather than help)
Constructors are special... interfaces don't specify them, and subclasses don't inherit them. There are many cases where you may not want your subclass to display a constructor from it's superclass. I know this sounds like I'm saying "there are many cases where you won't want a subclass to act exactly like a superclass, and then some (extend their functionality)", but its not, because constructors aren't how an object acts, they're how an object gets created.
As mlk said, the compiler will automatically create a default constructor, but not if there is already a constructor defined. So, unfortunatley for you, there wont be a default constructor made for SubClass that you could use to create it.
class SuperClass { //formerly inherit
int number;
public SuperClass () { //default constructor
number = 0;
public SuperClass (int n) {
number = n;
class SubClass extends SuperClass { //formerly inherit2
//DEFAULT CONSTRUCTOR, public SubClass() WILL NOT BE ADDED BY COMPILER
public SubClass (int n, int p) {
number = n*p;
class Example {
public static void main(String [] args) {
//attempted use of default constructor
//on a default constructorless subclass!
SubClass testSubClass = new SubClass();
If you're still at a loss, just remember: "Constructors aren't copy-pasted down from the superclass into the subclass!" and "Default constructors aren't added in if you add your own constructor in" :)
To get it to work, you'd have to add the constructor you used in main to SubClass (like doopsterus did with inheritedClass), or use the constructor you defined in SubClass for when you make a new one in main:
inherit2 obj = new inherit2(3,4);
Hope that cleared things up further, if needed. By the way, you should consider naming your classes as a NounStartingWithACapital, and only methods as a verbStartingWithALowercase