一、重写(方法覆盖)：

子类在继承父类的方法时，父类的方法无法满足子类的实际需求。此时子类就需要对父类的方法进行一个重写覆盖，如下面的例子：

父类：Person

public class Person {
    private String name;
    private int age;
    private char sex;

    public void setName(String name) {
         = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public char getSex() {
        return sex;
    }

    public void eat(){
        System.out.println("在吃饭");
    }
    public void sleep(){
        System.out.println("在睡觉");
    }
    public void showMe(){
        System.out.println("我叫:"++",我今年"+this.age+"岁,性别:"+this.sex);
    }
}

子类：Student：(子类"学生类"继承父类"人类")

public class Student extends Person {
    private String sid; //学生的学号

    public void setSid(String sid) {
        this.sid = sid;
    }

    public String getSid() {
        return sid;
    }

    public void study(){
        System.out.println("在学习");
    }

    @Override
    public void showMe() {
        System.out.println("我叫:"+this.getName()+",我今年"+this.getAge()+"岁,性别:"+this.getSex()+",我是一名学生,我的学号是:"+this.getSid());
    }
}

测试类如下：

public class Test {
    public static void main(String[] args) {
        Student student =new Student();
        student.setName("张无忌");
        student.setAge(24);
        student.setSex('男');
        student.setSid("2200130225");
        student.eat();
        student.sleep();
        student.study();
        student.showMe();
    }
}

代码的运行结果如下:

这样就充分展示了父类的方法无法满足子类的实际需求，就需要子类重写父类的showMe()方法，才能有子类学生的学号的输出，其中@Override的意思代表覆盖的意思。

1、特点：

(1)方法名一致。

(2)参数列表一致。

(3)返回值一致。

(4)访问权限可以不一样，但是子类的访问修饰符不能严格于父类。

(面试题常考:重写和重载的异同)

二、抽象方法（声明时需要使用abstract关键字修饰）

1、既然像上面例子中一样，父类方法的方法体里面的代码写的再多，或者不写，都对于子类来说用不到，干脆可以不写，然后将它改成抽象方法。

(1)抽象方法：方法体的内部实现与不实现没有任何价值和意义，不实现方法体。

(2) 没有方法体的方法即[抽象方法]，所以上面的父类的showMe()方法可改成:

public abstract void showMe();

(3)变成抽象方法后，没有方法体，也就无法调用它，(抽象方法只需要声明而不需要实现)，这时该方法处于的类就会报错，因为也要把它改成抽象类。为啥要变成抽象类呢，因为抽象类不能被实例化，简而言之就是无法new一个对象，也就无法调用里面的抽象方法了，也就刚好对应抽象方法。

public abstract class Person{  //变成抽象类
   //里面代码省略
   public abstract void showMe();  //抽象方法
}

三、抽象类（声明时需要使用abstract关键字修饰）

1、拥有抽象方法的类必然是抽象类

(1)抽象类不能被实例化。

(2)拥有抽象方法的类一定是抽象类，抽象类中不一定有抽象方法。(注意!)

例如下面例子：(抽象类中可以没有抽象方法)

   public abstract class Person{  //抽象类
      //部分代码省略 
      public void showMe(){
           System.out.println("我是一个普通方法");
    }
}

(3)抽象方法子类必须实现，如果子类不实现则子类也必须定义为抽象类，否则将会报错。

例如下面例子：(子类若不实现父类方法，必须将子类也定义为抽象类)

public abstract class Student extends Person{
     //代码省略
       /*
      @Override
     public void showMe() {
         System.out.println("我叫:"+this.getName()+",我今年"+this.getAge()+"岁,性 
 别:"+this.getSex()+",我是一名学生,我的学号是:"+this.getSid());
    }
      */  
         //将它实现父类的方法给注释掉，它就需要将子类也变成abstract抽象类，否则会报错
} 

(4)当父类是抽象类，父类里面的实例方法，它是有方法体的，子类继承过去是可以直接调用它的。也就是说父类的实例方法可以根据子类的实际需求看是否直接调用或者将其重写。

(5)抽象类也有构造方法(可以自己去试一试)。