1 继承的实现

1.1 继承的基本概念：扩展父类功能

1.2 Java中使用extends关键字完成继承；实现过程clas 子类 extends 父类{}

package com.jikexueyuan.extendsDemo;
class Person{
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    //public void tell(){
    //   System.out.println("姓名："+getName()+"   年龄："+getAge());
    //}
}
class Student extends Person{
    //private int age;
    //private String name;
    private int score;
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    public void say(){
        System.out.println("成绩："+getScore()+getName()+getAge());
    }
}
public class ExtendsDemo01 {
    public static void main(String[] args){
        Student s = new Student();
        s.setAge(20);
        s.setName("张三");
        s.setScore(100);
        //s.tell();
        s.say();
    }
}

Person与Student都属于人，所以Student类可以继承Person，这样Student就可以使用Person的属性，这样可以去掉很多冗余代码如上例中的所有注销的代码。

2 继承的限制

2.1 在Java中只允许单继承

这样属于单继承：

class People{
    private int age;
}
class Worker extends People{
}
class PetWorker extends Worker{
}

而这个样子就不属于单继承，在Java中是不被允许的。

class People{
    private int age;
}
class Worker extends People{
}
class PetWorker extends Worker,People{
}

2.2 子类不能直接访问父类的私有成员,同样需要实现其get和set方法来实现。

3 子类对象实例化过程

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

实例化子类对象→（先调用父类构造）调用父类构造→（在调用子类构造）调用子类构造

可以通过一段简单代码的执行结果看出：

package com.jikexueyuan.extendsDemo;
class Father{
    private int age;
    private String name;
    public Father(){
        System.out.println("父类的构造方法");
    }
}
class Son extends Father{
    public Son(){
        System.out.println("子类的构造方法");
    }
}
public class ExtendDemo03 {
    public static void main(String[] args){
        Son s = new Son();
    }
}

4 方法重写与super关键字

4.1 在继承中，也存在着重写的概念，其实就是子类定义了和父类同名的方法

4.2 定义：
– 方法名称相同，返回值相同，参数也相同。

定义2个类：

class A{
    public void tell(){
        System.out.println("我是tell方法");
    }
}
class B extends A{
    public void tell(){
        System.out.println("我重写了tell方法");
    }
}

通过实例化B 然后调用tell()方法：

public static void main(String[] args){
        B b = new B();
        b.tell();
    }

发现不会输出“我是tell方法”，只会输出“我重写了tell方法”。如果非要调用A类里的tell()方法，这时候就需要在B类里面加上super.tell();才能输出：

class B extends A{
    public void tell(){
        super.tell();
        System.out.println("我重写了tell方法");
    }
}

4.3 重写的限制

被子类重写的方法不能拥有比父类方法更加严格的访问权限。

加入父类有一个default级别的方法，在子类中重写这个方法的时候就不能用private级别，但可以使用default和public2个级别。通常情况下是子类的访问级别和父类一样。

4.4 访问权限

private < default < public

什么都不写就是default

• private只能在当前方法内访问。
• default只能在同一包下访问。
• public 可以在当前工程中访问。

4.5 super关键字：

强行调用父类的方法的执行。比如上面的强行调用A类的tell()方法执行。

而在构造方法中，不用加super，父类的构造方法也会执行，这是因为java会自动给构造方法加上super。

4.6 super不一定在重写中使用，也可以表示那些方法是从父类继承而来的。

5 重写与重载的区别