子类在覆盖父类方法的时候，父类的引用是可以调用该方法的，如果父类的引用调用子类的方法，那么这个多抛出来的异常，就可能处于一种无法被处理的状态(多态的用法)。下面，我就通过代码进行一下演示 demo：
我们先定义一个Animal类：
class Animal
{
public void eat()throws IOException,FileNotFoundException
{
System.out.println("eat");
}
}
接着，我们再定义一个Tiger类继承该Animal类
class Tiger extends Animal
{
public void eat()throws IOException ,Exception
{
System.out.println("Tiger eat animal");
}
}
这样，tiger的eat方法里，就有一个Exception 异常，这个异常的级别高于IO。也就是说对IO异常的处理，无法处理Exception 异常。
这个时候，如果我们定义一个测试方法，测试动物吃东西这个方法。
如下：
class Test
{
public void TestAnimalEat(Animal a)
{
try
{
a.eat();
}
catch(FileNotFoundException e1)
{
e1.printStackTrace();
}
catch(IOException e2)
{
e2.printStackTrace();
}
}
}
那么，这个方法是完全正确的，因为他处理了eat方法的两个异常。一个抛出，一个捕获。
这个时候，如果我们再进行如下的操作：
class TestDemo
{
public static void main(String[] args)
{
Test t = new Test();
Tiger tiger = new Tiger();
t.TestAnimalEat(tiger);
}
}
则在调用tiger对象的时候，Test中的TestAnimalEat()方法只处理Animal类的eat()方法的两个异常，而这个Tiger类中的eat()方法多出来的Exception，就无法进行处理。所以，JAVA就不允许做这种子类抛出比父类更多的异常。
当然，这里说更多是不合适的，子类不能抛出父类异常本身和其子异常以外的其他异常。比如，如果父类抛出一个Exception 异常，那么子类就可以随心所欲的抛出很多的异常了。因为这些异常都是父类异常的子异常。因为用到了多态，动态绑定的特性。深刻理解了多态的写法上面就理解了。
那么如果要联系现实，应该如何说呢。
一个修理家电的人，他能够修理冰箱，电脑，洗衣机，电视机。 一个年轻人从他这里学的技术，就只能修理这些家电，或者更少。你不能要求他教出来的徒弟用从他这里学的技术去修理直升飞机。

2、  方法覆写：
·子类方法的名称、参数名、返回类型与父类方法一致。
·子类方法不能缩小父类方法的访问权限。
·子类方法不能抛出比父类方法更多的异常子类。
·父类的静态方法不能被子类覆盖为非静态方法。（一下代码会导致编译错误）。

public class Sup {
    public static void methed1(){
    }
}
public class Sub extends Sup {
    public void  methed1(){  /*警告，编译有错误*/
    }
}

·子类可以定义与父类的静态方法同名静态方法，以便在子类中隐藏父类的静态方法。（但是也必须满足：子类方法的名称、参数名、返回类型与父类方法一致、子类方法不能缩小父类方法的访问权限、子类方法不能抛出比父类方法更多的异常子类的条件）
·子类的非静态方法不能被子类覆盖未静态方法。（编译出错）

public class Sup {
    public void methed1(){
    }
}
public class Sub extends Sup {
    public static void  methed1(){  /*警告，编译有错误*/
    }
}


 

·所以由上面可以知道：子类复写与父类时，方法只能同时为Static，而不能一个为static一个不是static类型。
·父类的抽象方法可以被子类通过两种途径覆盖：1,、子类实现了父类的抽象方法；2、是子类重新声明父类的抽象方法。

public abstract class Sup {
    abstract void methed1();
    abstract void methed2();
}
public abstract class Sub extends Sup {
    void  methed1(){//实现父类的方法
    }
     abstract void  methed2();//重新声明method2方法。
}

·父类的非抽象方法可以被覆盖未抽象方法。

public abstract class Sup {
    void methed1(){
    }
}
public abstract class Sub extends Sup {
     abstract void  methed1();//合法
}

 

1.方法的覆盖（重写）：

就是在子类中重写了与父类中有相同名字的方法。

2、方法的覆盖原则：

（1）覆盖方法的返回类型、方法名称、参数列表必须与原方法相同。

（2）覆盖方法不能比原方法访问性差（即访问权限不允许缩小）

（3）覆盖方法不能比原方法抛出更多的异常。

（4）被覆盖的方法不能是final类型，因为final修饰的方法是无法覆盖的。

（5）被覆盖的方法不能为private, 否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

（6）被覆盖的方法不能为static。如果父类中的方法为静态，而子类中的方法不是静态，但是两个方法除了这-点外其他都满足覆盖条件，那么就会发生编译错误;反之亦然。

（7）即使父类和子类中的方法都是静态的，并且满足覆盖条件，但是仍然不会发生覆盖，因为静态方法是在编译的时候把静态方法和类的引用类型进行匹配。

1、子类方法的名称、参数签名和返回类型必须与父类方法的名称、参数签名和返回类型一致

2、子类方法不能缩小父类方法的访问权限

3、子类方法不能抛出比父类方法更多的异常

4、方法覆盖只存在于子类和父类之间。在同一个类中方法只能被重载，不能被覆盖

5、父类的静态方法不能被子类覆盖为非静态方法

6、子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法

        子类隐藏父类的静态方法和子类覆盖父类的实例方法的区别：静态方法与所属的类绑定，而实例方法与所属的

        实例绑定

7、父类的非静态方法不能被子类覆盖为静态方法

8、父类的私有方法不能被子类覆盖

9、父类的抽象方法可以被子类通过两种途径覆盖：一是子类实现父类的抽象方法；二是子类重新声明父类的抽象方法

10、父类的非抽象方法可以被覆盖为抽象方法