Ⅰ java中覆盖方法带有抛出异常的情况
子类覆盖父类方法抛出异常不能比父类多 这句话表述有些问题
正确应该是子类抛出的异常类型不能比父类抛出的异常类型更宽泛
通俗一点讲就是：子类的异常类型不能比父类的异常类型更大或更多
例如父类方法抛出一个FileNotFoundException，这时候子类可以抛出FileNotException或者其子类，例如我自己写了File1Exception,File2Exception，他们都继承自FileNotException，这时候子类可以同时抛出File1Exception和File2Exception，因为他们都是FileNotFoundException，满足“子类抛出的异常类型不能比父类抛出的异常类型更宽泛”这个条件 同时子类还可以抛出RuntimeExceptioin这是运行时异常，不受上面条件的约束！
为什么设计成这样呢？ 举个现实的例子：我们现在有个动物类，它有个方法叫 eat() ，吃东西会抛出被毒死的异常，这是吃东西唯一可能出现的异常情况！ 那么我们的子类在重写eat()方法时可以抛出 毒死异常或其子类，如"误把老鼠药当食物被毒死异常”、"吃有毒蘑菇被毒死异常“.....
但是子类就是不能抛出毒死异常之外的 如”撑死异常“或者”噎死异常“，因为父类是个大前提，指所有动物，animal总共才抛出毒死异常这个类型，你子类就不能抛出我类型之外的状况！
例子举的不太好，但是可以帮助理解。
Ⅱ 有关java中子类覆盖父类的方法的返回值的问题
很简单，在这个method里面的时候，你写name，系统不会自动匹配super.name而是自动匹配this.name,由于你这个name在this里面没有，所以系统就找不到了。你写成super.name应该也能通过。
Ⅲ JAVA中子类重写父类的方法，怎么写，什么要求
1.父类的方法不能降级，同级的话就要覆盖，例如public方法不能在子类中被声明为protected或者private（子类重载除外），否则会有
Cannot rece the visibility of the inherited method from Father的编译错误。
2.父类的方法可以任意升级，但升级只有两种方式，要么覆盖，要么重载，覆盖就是方法体完全一样，重载则是参数必须改变，方法名称不变。
importjava.lang.reflect.Method;
classFather{
inta;
protectedintb=5;
protectedvoidfuncpro(){
//父类的保护方法，子类能够访问，但子类自身没有
System.out.println("fatherfuncpro");
}
publicvoidfuncpub(){
//父类公有方法，子类直接继承
}
privatevoidfuncpri(){
//父类私有方法，子类不可见
}
}
{
/**
*@paramargs
*/
//父类保护方法的重写
//publicvoidfuncpro(){
////子类自己可以这样定义，将会覆盖父类protected方法
//System.out.println("子类的func方法");
//}
//protectedvoidfuncpro(){
////ok
//}
//publicshortfuncpro(){
////illegal父类的protected和public方法在子类中是可见的，试想一下，如果编译器认为这个方法体正确，
//那么子类调用funcpro的时候究竟调用哪个呢？这样没有能构成重载
//}
//privatevoidfuncpro(){
////illegal
//}
privatevoidfuncpro(inta){
//这是方法重载，不会报错
System.out.println("sunfuncpro");
}
//父类公有方法的重写
//privatevoidfuncpub(){
////illegal：
//}
//protectedvoidfuncpub(){
////illegal
//}
//publicvoidfuncpub(){
////ok
//}
//publicintfuncpub(){
////illegal和父类的返回值不匹配
//}
//publicintfuncpub(inti){
////ok子类构成重载
//return1;
//}
//父类私有方法的重写
//publicvoidfuncpri(){
////ok
//}
//protectedvoidfuncpri(){
////ok
//}
//privatevoidfuncpri(){
////ok
//}
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
TestOveridetestOveride=newTestOveride();
Classclass1=testOveride.getClass();
try{
Method[]methods=class1.getMethods();
System.out.println("子类中的所有方法：");//可以看到，并没有父类的funcpro方法
for(Methodm:methods){
System.out.println(m);
}
System.out.println("子类调用父类的protected方法：");
testOveride.funcpro();
System.out.println("子类调用自己的func方法：");
testOveride.funcpro(1);
System.out.println("子类调用父类的字段");
System.out.println(testOveride.b);
}catch(Exceptione){
e.printStackTrace();
}
}
}
Ⅳ java 父类方法名称为private，则子类无法覆写，也不会这样去编写代码
我觉得这样写是可以的。但是！！！！这样写出来的print()方法就不叫“覆写父类方法"了，它会当你是在子类里边重新定义了一个名为print的方法。
如果你觉得这样对父类方法覆写时不保险，建议你在覆写方法前加上”@Override“,这样如果你想覆写，按照你上边写的，编译器就不会通过编译，也就不会出现上边所说的”它会当你是在子类里边重新定义了一个名为print的方法“问题，这是最保险的做法。我认为。
Ⅳ 被覆盖的方法无法抛出异常
javainlife 的代码为什么能打印出a，那是因为其抛出的异常是RuntimeException，所以在b.java中
public void a() throws RuntimeException
public void a()
两中写法是等价的
覆盖有个原则
子类覆盖父类的方法，那么子类方法声明抛出的异常必须是父类方法声明抛出的异常的本身或者其子类
比如说父类上面抛出Exception
那么子类方法声明可以抛出Exception 或者Exception的子类异常
下面的代码可以看看：
class MyException extends RuntimeException{
}
interface a{
public void aa();
}
class b implements a{
public void aa()throws MyException{
}
}
编译没问题
Ⅵ java覆盖问题。覆盖父类方法抛出异常问题
重写方法需要抛出与原方法所抛出异常类型一致异常或不抛出异常。
一个方法是否显示抛出异常对于重写是没用影响的，只是对调用者有影响，对于使用者来说如果你抛出的是一个未报告的异常那他就要必须使用trycatch来捕获异常了。而且你要注意如果说你显示抛出一个UnsupportedOperationException之类的异常，调用该方法可以不用自己来亲自捕获异常的，可以直接再往上次抛。RuntimeException异常类以及其子类都属于此范畴，调用者可以不用自己去捕获异常的！
子类抛出的异常类型不能比父类抛出的异常类型更宽泛！
对于这句话你还少了一个条件应该是子类重写父类方法不能抛出比父类更宽的异常类型的把。其实理解这个很简单，比如说宪法规定骂人只承担民事责任，到了刑法里就不能说直接枪毙了，这就是一个约束能力的问题，子类行为不能超出父类约束范畴。否者就容易乱套。就像父类的某方法公有的，子类就不能重写改成私有的了。这就是一个约束力的问题。
还有我查到说抛出runtime异常没有问题。运行时异常虽然可以不用捕获。但如果其本身已经超出了父类的范围呢？
这个还是拿宪法民事责任来说把，宪法说骂人教育一下就可以了，到了省里说道个歉就可以了，但是到了市里了，不光道歉还要写检讨。这些都是可以的，因为他们本身就有处理这个事件的能力。子类方法他可以不管RuntimeException之类的异常，这是前提，就算你父类方法声明的异常更小，我可以行使我抛出RuntimeException异常的权利，这个是我的本身就有的权利。这就像是地方政策和国家政策相抵触的时候，老百姓可以直接往国家报告，可以不经过地方政府一样，因为老百姓有直接上报国家的权利。子类有RuntimeException异常不报告的权利，就算你父类规定个更低的异常，我一样可以上报，只要你比RuntimeException低级就可以。
这就好比，卖国贼选择了卖国，他们的子女就不能爱国了一样!
Ⅶ java子类覆盖(override)父类的方法, 异常如何处理
子类在覆盖父类带throws子句的方法时，子类的方法声明中的throws子句抛出的异常不能超出父类方法的异常范围，因此，throws子句可以限制子类的行为。换句话说，子类的方法抛出的异常只能和父类方法一致，或者是不抛出异常，但是不能出现父类对应方法的throws子句中没有的异常类型
Ⅷ c# 子类覆盖父类方法
# 对方法的重载必须要显式声明，这个与 C++ 和 JAVA 都不同。见下面的 C# 程序：
classPlane
{
publicdoubleTopSpeed()
{
return300.0D;
}
}
classJet:Plane
{
publicdoubleTopSpeed()
{
return900.0D;
}
}
classAirport:IEntryPoint
{
publicvoidMain()
{
Planeplane=newJet();
Console.WriteLine("planestopspeed:{0}",plane.TopSpeed());
}
}
上面的程序很简单，在编译时会有警告：警告:“Jet.TopSpeed()隐藏了继承的成员Plane.TopSpeed()。如果是有意隐藏，请使用关键字 new。"E:.cs9217LearningCSharpByExample
但结果却出乎意料地是：
planes top speed: 300
很显然，它并没有调用子类的 TopSpeed 方法。原因是在 C# 中，方法如果想要被重载，必须显式地声明为 virtual，也就是虚方法。而继承类如果要重写此方法时，也必须显式地声明为 override ，这样才能覆盖父类方法。C# 代码如下：
classPlane
{
publicvirtualdoubleTopSpeed()
{
return300.0D;
}
}
classJet:Plane
{
publicoverridedoubleTopSpeed()
{
return900.0D;
}
}
classAirport:IEntryPoint
{
publicvoidMain()
{
Planeplane=newJet();
Console.WriteLine("planestopspeed:{0}",plane.TopSpeed());
}
}
以上程序的输出结果是：
planes top speed: 900
在 C# 中，如果一个方法允许子类覆盖，则必须要显式声明为 virtual 的（在 JAVA 中，默认是 virtual 的），并且在子类里必须显式声明为 override。这两个关键子哪个也不能省。顺便再说一下另外的三个关键字：sealed、abstract、new。
在继承 abstract 类的 abstract 方法时，也必须声明方法为 override，abstract 方法的特性与 JAVA 中的抽象类是一样的。sealed 关键字意思是密封的，相当于 JAVA 中的 final，在类上使用是不可再被继承，在方法上使用是不可再覆盖；但还有一个例外，就是对方法使用 new 关键字声明。代码如下：
abstractclassPlane
{
publicvirtualdoubleTopSpeed()
{
return300.0D;
}
}
classJet:Plane
{
()
{
return900.0D;
}
}
classUFO:Jet
{
publicnewdoubleTopSpeed()
{
return13000.0D;
}
}
classAirport:IEntryPoint
{
publicvoidEntryPoint()
{
UFOplane=newUFO();
Console.WriteLine("planestopspeed:{0}",((Plane)plane).TopSpeed());
Console.WriteLine("planestopspeed:{0}",((Jet)plane).TopSpeed());
Console.WriteLine("planestopspeed:{0}",((UFO)plane).TopSpeed());
}
}
注意，我是把 UFO 对象强转成某一对象然后调用其 TopSpeed 方法的，上面程序的输出结果是：
planes top speed: 900
planes top speed: 900
planes top speed: 13000
总之：C# 在这方面增加了方法定义的灵活性，给用户的更大的权利。但用不好会出现比较奇怪的结果。所以我觉得在定义方法时全部都加上 sealed 或是 virtual 关键字，这样避免继承的类出错.