​

 /*
 * 重写要遵循"两同两小一大"原则:
 * 1)两同:
 *   1.1)方法名相同
 *   1.2)参数列表相同
 * 2)两小:
 *   2.1)子类方法的返回值类型小于或等于父类的
 *       2.1.1)void时，必须相同
 *       2.1.2)基本类型时，必须相同
 *       2.1.3)引用类型时，小于或等于
 *   2.2)子类方法抛出的异常小于或等于父类的
 * 3)一大:
 *   3.1)子类方法的访问控制权限大于或等于父类方法的访问控制权限
 */

 

一、两同：

方法名相同，参数列表相同

 

二、两小1：

子类方法的返回值类型需要小于或等于父类的方法的返回值类型。

具体要求如下：

 *       2.1.1)void时，必须相同

package aaf_overwrite;

import java.awt.*;
import java.io.IOException;

/**当子类重写超类含有throws声明异常抛出的方法时，对throws的重写规则*/
public class ThrowsDemo {
    public void dosome()throws IOException, AWTException {
    }
}


class SubClass extends ThrowsDemo{//子类SubClass重写父类ThrowsDemo的dosome()方法
    //子类重写父类的dosome()方法时： 父类方法的返回值类型是void时，子类方法返回值类型也需要是void(和父类相同)
    public void dosome() {
    }
}

 *       2.1.2)基本类型时，必须相同

package aaf_overwrite;

import java.awt.*;
import java.io.IOException;

/**当子类重写超类含有throws声明异常抛出的方法时，对throws的重写规则*/
public class ThrowsDemo {

    public int dosome(int x)throws IOException, AWTException {
        return x*x;
    }

}


class SubClass extends ThrowsDemo{//子类SubClass重写父类ThrowsDemo的dosome()方法

    //2.子类重写父类的dosome()方法时： 
    //父类方法的返回值类型是基本时，子类方法返回值类型需要和父类相同
    public int dosome(int x){//重写int dosome(int x)
        return x*x;
    }

}

 

 *       2.1.3)引用类型时，小于或等于

package aaf_overwrite;

import java.awt.*;
import java.io.IOException;

/**当子类重写超类含有throws声明异常抛出的方法时，对throws的重写规则*/
public class ThrowsDemo {
    public Object dosome(double y)throws IOException, AWTException {
        return y*y;
    }
}


class SubClass extends ThrowsDemo{//子类SubClass重写父类ThrowsDemo的dosome()方法

    //3.子类重写父类的dosome()方法时：
    // 父类方法的返回值类型是引用类型时，
    //子类方法返回值类型需要是父类方法返回值类型的子类型或和父类方法的返回值类型相同。
    public Double dosome(double y){//Object dosome(double y)
        return y*y;
    }
}

 

 

三、两小2：

子类重写父类的方法时： 子类方法抛出的异常小于或等于父类的异常(需要是父类方法的子类异常)

上边的语法要求的具体内容如下：

  • 允许和父类方法抛出同样的异常
  • 允许不再抛出任何异常. 
  • 允许仅抛出部分异常
  • 允许抛出超类方法声明抛出异常的子类型异常
  • 不允许抛出额外异常(超类方法没有声明的且不存在继承关系的)
  • 不允许抛出超类方法抛出异常的超类型异常

测试代码如下：

package aaf_overwrite;

import java.awt.*;
import java.io.IOException;

/**当子类重写超类含有throws声明异常抛出的方法时，对throws的重写规则*/
public class ThrowsDemo {
    public void dosome()throws IOException, AWTException {
    }
}


class SubClass extends ThrowsDemo{//子类SubClass重写父类ThrowsDemo的dosome()方法
    //1.允许和父类方法抛出的异常相同
    //public void dosome()throws IOException, AWTException {
    //}

    //2.允许不再抛出任何异常
    //public void dosome(){
    //}

    //3.允许仅抛出部分异常
    //public void dosome()throws IOException{
    //}

    //4.允许抛出超类方法声明抛出异常的子类型异常
    //public void dosome()throws FileNotFoundException {
    //}

    //5.不允许抛出额外异常(超类方法没有声明的且不存在继承关系的)
    //public void dosome()throws SQLException {
    //}

    //不允许抛出超类方法抛出异常的超类型异常
    //public void dosome()throws Exception {
    //}
}

 

//父类大，子类小
class Coo{
    void show(){}
    double say(){return 0.0;}
    Doo sayHi(){return null;}
    public Coo test(){return null;}
}
class Doo extends Coo{
    //int show(){return 1;} //编译错误，void时必须相同
    //int say(){return 0.0;} //编译错误，基本类型时必须相同
    //Coo sayHi(){return null;} //编译错误，引用类型必须小于或等于
    public Doo test(){return null;}
}

 四、一大：

子类方法重写父类方法时： 子类方法的访问控制权限大于或等于父类方法的访问控制权限

注意： 如果用public修饰则可以相同，否则只能更大

package aaf_overwrite;

import java.awt.*;
import java.io.IOException;

/**当子类重写超类含有throws声明异常抛出的方法时，对throws的重写规则*/
public class ThrowsDemo {
    protected void dosome()throws IOException, AWTException {
    }
}


class SubClass extends ThrowsDemo3{//子类SubClass重写父类ThrowsDemo的dosome()方法
    //子类方法的访问控制修饰符的权限需要大于等于父类方法的访问控制修饰符的权限
    //private < 默认(不写访问控制修饰符) < protected < public
    public void dosome()throws IOException, AWTException {
    }

    //父类方法的访问控制修饰符如果是public，则子类方法进行重写时也可以用public修饰。
    //父类方法的访问控制修饰符如果是protected，则子类方法进行重写时也不能用protected修饰。
    /*protected void dosome()throws IOException, AWTException {
    }*/
}

 

                                                                                                                                                                                                               2024-05-27   by zhaoyq