一、继承的实现

• 继承的基本概念： 扩展父类的功能
• Java中使用extends关键字完成继承：class 子类 extends 父类 { }

代码
class PersonB{
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
//  public void tell() {
//      System.out.println("姓名："+getName()+"  年龄："+getAge());
//  }
    
}
class StudentB extends PersonB{
//  private int age;
//  private String name;
    private int score;
//  public int getAge() {
//      return age;
//  }
//  public void setAge(int age) {
//      this.age = age;
//  }
//  public String getName() {
//      return name;
//  }
//  public void setName(String name) {
//      this.name = name;
//  }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    
    public void say() {
//      System.out.println("成绩："+getScore());
        System.out.println("姓名："+getName()+"  年龄："+getAge()+"   成绩："+getScore());
    }
}
public class Demo15 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        StudentB sB = new StudentB();
        sB.setAge(20);
        sB.setName("张小");
        sB.setScore(100);
//      sB.tell();
        sB.say();
    }
}
结果：
姓名：张小  年龄：20   成绩：100

二、继承的限制

• 在Java中只允许单继承。
• 子类不能直接访问父类的私有成员。

代码
class PeopleB{
    private int age;

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
class Worker extends PeopleB{
    public void tell() {
        System.out.println(getAge());
    }
}
//class PetWorker extends Worker{
//  public void tell() {
//      System.out.println(age);
//  }
//}
public class Demo16 {
    public static void main(String[] args) {
        Worker w = new Worker();
        w.setAge(100);
        w.tell();
    }
}
结果：
100

三、子类对象实例化过程

在子类对象实例化之前，必须先调用父类中的构造方法，之后调用子类构造方法。

过程.jpg

代码
class Father{
    public Father(){
        System.out.println("父类的构造方法");
    }
}
class Son extends Father{
    public Son(){
        System.out.println("子类的构造方法");
    }
}
public class Demo17 {
    public static void main(String[] args) {
        Son s = new Son();
    }
}
结果：
父类的构造方法
子类的构造方法

四、方法重写与super关键字

• 在继承中，也存在着重写的概念，其实就是子类定义了和父类同名的方法。
• 定义：方法名称相同，返回值类型相同，参数也相同。
• 重写限制：被子类重写的方法不能拥有比父类方法更加严格的访问权限。
• 访问权限：private < default < public
• super关键字：强行调用父类的方法的执行。
• super不一定在重写中使用，也可以表示那些方法是从父类中继承而来的。

代码
class A{
    public void tell() {//可以在整个工程下都可以访问
        System.out.println("我是tell方法");
    }
    private void say1(){ //私有的，只有在当前类中访问
        
    }
    void print(){ //default 可以在同一包下进行访问
        
    }
}
class B extends A{
    public void tell() {
        super.tell();
        System.out.println("我重写了tell方法");
    }
}
public class Demo18 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        B b = new B();
        b.tell();
    }
}
结果：
我是tell方法
我重写了tell方法

五、重写与重载的区别