继承

class BaseAction {
    
    BaseAction(){
        System.out.println("父类，无参构造方法");
    }
    
    BaseAction(String name){
        System.out.println("父类，含一个参数的构造方法" + name);
    }
}

class UserAction extends BaseAction{
    
    UserAction(){
        System.out.println("子类，无参构造方法");
    }
    
    UserAction(String name){
        System.out.println("子类，含一个参数的构造方法" + name);
    }
    
}

 

    
    public static void main(String[] args){
        UserAction u = new UserAction();
    }
    
}

运行结果：

父类，无参构造方法
子类，无参构造方法

 

 

    
    public static void main(String[] args){
        UserAction u = new UserAction("张三");
    }
    
}

 

运行结果：

父类，无参构造方法
子类，含一个参数的构造方法张三

 

 

 

    
    public static void main(String[] args){
        BaseAction m = new BaseAction();
    }
    
}

 

运行结果：

父类，无参构造方法

 

 

    
    public static void main(String[] args){
        BaseAction m = new BaseAction("张三");
    }
    
}

 

运行结果：

父类，含一个参数的构造方法张三

 

总结：在实例化对象时，默认调用对象的无参构造方法，如果该对象继承了父类，会最先调用父类的无参构造方法。

每个子类的构造方法中的第一行都有一句隐式的super()语句。

 

 

在什么时候用继承?

现在在InfoAction中有方法findAll()和getName()，但是在UserAction中也需要一个和InfoAction相同功能的findAll方法：

    public void findAll(){
        
    }
    
    public void getName(){
        
    }
}

class UserAction{
    
    public void findAll(){
        
    }
}

 

如果改为UserAction继承InfoAction似乎可以实现，这样UserAction具备了InfoAction所有的功能：

    public void findAll(){
        
    }
    
    public void getName(){
        
    }
}

class UserAction extends InfoAction{
    
    
}

 

但是UserAction只需要InfoAction中的findAll方法，这样我们可以继续向上抽取，UserAction和InfoAction出现一个共同的父类：

class BaseAction {
    
    public void findAll(){
        
    }
}

class InfoAction extends BaseAction{

    public void getName(){
        
    }
}

class UserAction extends BaseAction{
    
    
}