Java基础九（方法的重写）

方法的重写（override/overwrite）

1.重写：子类继承父类后，可以对父类中同名同参数的方法，进行覆盖操作

2.应用：重写以后，当创建子类对象以后，通过调用子类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

3.重写规定：

• 方法的声明：权限修饰符 返回值类型 方法名（形参列表） throws 异常的类型{ //方法体}
• 约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
    （1）子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
    （2）子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
      >特殊情况：子类不能重写父类中的private方法
    （3）返回值类型：
       >父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
      >父类被重写的方法的返回值是A类型，则子类重写的方法的返回值类型可以是A类或者A类的子类
       >父类被重写的方法的返回值是基本数据类型（比如：double），则子类重写的方法的返回值类型必须是相同的基本数据类型（double）
    （4）子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理的时候说明）
      子类和父类中同名同参数的方法要么都声明为非static（考虑重写），要么都声明为static（不是重写）的。static方法不能重写

public class PersonTest {
   public static void main(String[] args) {
       Student s = new Student("计算机科学与技术学院");
       //重写后的方法
       s.eat();
       s.walk(10);

       System.out.println("********************************");

       s.study();

       Person p1 = new Person();
       //原方法
       p1.eat();

       s.show();
   }
}

public class Person {
    String name;
    int age;
    public Person(){

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println("吃饭");
    }

    public void walk(int distance){
        System.out.println("走路，走的距离是：" + distance + "公里");
        show();//原方法
        eat();//被重写
    }

    private void show(){
        System.out.println("我是一个人");
    }

    public Object info(){
        return null;
    }
}

public class Student extends Person{
    String major;
    public Student(){

    }

    public Student(String major) {
        this.major = major;
    }

    public void study(){
        System.out.println("学习。专业是：" + major);
    }

    //对父类中的eat方法进行重写
    public void eat(){
        System.out.println("学生应该多吃有营养的食物");
    }

    //不被认定为重写方法
    public void show(){
        System.out.println("我是一个学生");
    }

    //对应person中的object
    public String info(){
        return null;
    }

//    @Override
    public void walk(int distance) {
//        super.walk(distance);
        System.out.println("重写的方法");
    }
}

关于权限的补充

同一个包中

• 同一个包中的其他类，不可以调用Order类中私有的属性、方法

public class Order {
    private int orderPrivate;
    int orderDefault;
    protected int orderProtected;
    public int orderPublic;

    private void methodPrivate(){
        orderPrivate = 1;
        orderDefault = 2;
        orderProtected = 3;
        orderPublic = 4;
    }

    void methodDefault(){

    }

    protected void methodProtected(){

    }

    public void methodPublic(){

    }
}

public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order();

        order.orderDefault = 1;
        order.orderProtected = 2;
        order.orderPublic = 3;

        order.methodDefault();
        order.methodProtected();
        order.methodPublic();

        //同一个包中的其他类，不可以调用Order类中私有的属性、方法
//        order.orderPrivate = 4;
//        order.orderPrivate();

    }
}

不同包中

• 不同包下的普通类（非子类）要使用Order类，不可以调用声明为private、缺省、protected权限的书性、方法
• 在不同包的子类中，不能调用Order类中声明为private和缺省权限的属性、方法

public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order();

        order.orderPublic = 3;
        order.methodPublic();

        //不同包下的普通类（非子类）要使用Order类，不可以调用声明为private、缺省、protected权限的书性、方法
//        order.orderDefault = 1;
//        order.orderProtected = 2;
//        order.orderPrivate = 4;
//
//        order.methodDefault();
//        order.methodProtected();
//        order.orderPrivate();
    }

    public void show(Order order){
        order.orderPublic = 3;
        order.methodPublic();

        //不同包下的普通类（非子类）要使用Order类，不可以调用声明为private、缺省、protected权限的书性、方法
//        order.orderDefault = 1;
//        order.orderProtected = 2;
//        order.orderPrivate = 4;
//
//        order.methodDefault();
//        order.methodProtected();
//        order.orderPrivate();
    }
}

public class SubOrder extends Order {
    public void method(){
        orderProtected = 1;
        orderPublic = 2;

        methodProtected();
        methodPublic();

        //在不同包的子类中，不能调用Order类中声明为private和缺省权限的属性、方法
//        orderDefault = 3;
//        orderPrivate = 4;
//
//        methodDefault();
//        methodPrivate();
    }
}