重写与隐藏，有些书上或介绍上可能名称不一样，但都大差不差。以前只了解重写，隐藏也听说过，但没有详细了解过，趁现在，整理一下这两方面的内容吧。
首先，先说一下概念方面的东西。
重写
重写：子类继承了父类，在子类中声明了与父类具有相同的方法名称与参数列表，并且具有相同的返回类型(或者子类的返回类型是父类的子类型)的实例方法，那么就说子类重写了父类中的同名方法(但父类的方法必须在子类中可见)，而重写则是实现多态的前提；子类可以向上转型为父类类型，这样，当通过父类的引用来调用重写的方法时，就可以表现出子类的行为。
1. 如果子类重写了父类的方法，则有如下要求：
（1）子类与父类的方法必须都是实例方法，即都不是静态方法；
（2）子类与父类的方法需要具有相同的方法名称，参数列表，并且子类的返回类型与父类相同，或者是父类的子类型；
public class JavaTest extends Super {
@Override
public Integer print() {
return null;
}
}
class Super {
public Object print() {
return null;
}
}
由于Integer是Object的子类，因此满足重写的条件。
（3）子类方法的访问权限不能小于父类的访问权限(可以有相同的访问权限)；
public class JavaTest extends Super {
@Override
protected Integer print() {
return null;
}
}
class Super {
public Object print() {
return null;
}
}
访问权限由高到低依次为public，protected，包的访问权限，private。如果子类方法的访问权限低于父类的访问权限，那么编译器将给出错误信息。如上面的代码，编译器就会报错。
（4）子类方法不能比父类方法抛出更多的已检测异常(也称编译时异常)，即子类方法抛出的异常必须是父类的子集或和父类是相同的异常；
public class JavaTest extends Super {
@Override
public Integer print() throws IOException {
return null;
}
}
class Super {
public Object print() throws FileNotFoundException{
return null;
}
}
如上面代码，由于父类抛出的FileNotFoundException异常是子类抛出的IOException异常的子类，这是不允许的。
注意：如果是未检测异常(运行时异常)，则不受此限制，子类也不用显示的使用throws抛出。
（5）父类的方法在子类中必须可见(子类可以使用super来访问父类中被重写的方法);
public class JavaTest extends Super {
public Integer print() {
return null;
}
}
class Super {
private Object print() {
return null;
}
}
如上面代码，父类中的方法是private类型的，在子类是无法访问的，但这不属于重写；
2.重写方法的调用
当子类向上转型为父类类型A，通过父类的引用来调用某个方法时，Java编译器会先检查当前类有没有实现同名方法，如果有，执行当前类的方法；若没有，则去执行父类的同名方法；若父类没有，则再检查父类的父类有没有实现这个方法，以此类推，直到父类A为止。
public class JavaTest {
public static void main(String[] args) {
SuperClass test = new ThatClass();
test.print1();
test.print2();
test.print3();
}
}
class ThatClass extends ThisClass {
public void print1() {
System.out.println("ThatClass print1()");
}
}
class ThisClass extends SuperClass {
public void print1() {
System.out.println("ThisClass print1()");
}
public void print2() {
System.out.println("ThisClass print2()");
}
}
class SuperClass {
public void print1() {
System.out.println("SuperClass print1()");
}
public void print2() {
System.out.println("SuperClass print2()");
}
public void print3() {
System.out.println("SuperClass print3()");
}
}
执行结果如下：
ThatClass print1() ThisClass print2() SuperClass print3()
还有一种情况，当使用父类的引用调用某个方法（如A方法）时，如果A方法中又调用了另一个父类中的方法（假设为B方法），那么依然按照上述的原则来查找B方法（由子类到父类的查找顺序）；
public class JavaTest {
public static void main(String[] args) {
SuperClass test = new ThatClass();
test.print3();
}
}
class ThatClass extends ThisClass {
public void print1() {
System.out.println("ThatClass print1()");
}
}
class ThisClass extends SuperClass {
public void print1() {
System.out.println("ThisClass print1()");
}
public void print2() {
System.out.println("ThisClass print2()");
}
}
class SuperClass {
public void print1() {
System.out.println("SuperClass print1()");
}
public void print2() {
System.out.println("SuperClass print2()");
}
public void print3() {
System.out.println("SuperClass print3()");
print2();
print1();
}
}
打印结果如下：
SuperClass print3() ThisClass print2() ThatClass print1()
简单分析下，父类引用调用print3方法，由于子类都没有重写，所以调用父类的方法，而父类print3方法又调用了父类的其他两个方法，并且这两个方法在子类中均可见，因此按照由子类到父类的查找顺序进行。由于print1方法在子类中被重写，所以调用子类的print1方法，而print2在子类中没有被重写，而是在子类的直接父类中被重写，所以调用子类的直接父类的print2方法。
注意：JDK5.0之后可以使用@Override注解来标明要重写的方法。如果没有重写，编译器就会报错，如下，编译器就会报错。
class ThatClass extends ThisClass {
@Override
public void print1() {
System.out.println("ThatClass print1()");
}
}
class ThisClass {
private void print1() {
System.out.println("ThisClass print1()");
}
}
隐藏
1. 什么是隐藏呢？
隐藏其实和重写差不多，除了隐藏要求所有的方法都是静态方法，而重写是实例方法，其他的要求都是一样的。
其实隐藏与重写最本质的区别是，重写是多态的前提，利用重写可以实现多态，而隐藏则无法实现多态。
下面通过一个简单的例子来了解一下：
public class JavaTest {
public static void main(String[] args) {
SuperClass superTest = new ThisClass();
superTest.hiding();
superTest.override();
System.out.println("===================");
ThisClass thisTest = (ThisClass)superTest;
thisTest.hiding();
thisTest.override();
}
}
class ThisClass extends SuperClass {
public void override() {
System.out.println("ThisClass void override()");
}
public static void hiding() {
System.out.println("ThisClass static void hiding()");
}
}
class SuperClass {
public void override() {
System.out.println("SuperClass void override()");
}
public static void hiding() {
System.out.println("SuperClass static void hiding()");
}
}
结果如下：
SuperClass static void hiding() ThisClass void override() =================== ThisClass static void hiding() ThisClass void override()
通过以上例子，我们发现了重写与隐藏的根本区别：
（1）如果子类重写了父类的方法，则通过父类的引用调用的是子类的方法；
（2）如果子类隐藏了父类的方法，则通过父类的引用调用的仍然是父类的方法；
（3）这表明了实例方法的调用是动态绑定的，是在运行的时候根据对象真正的类型来决定调用哪个方法，而静态方法的调用是静态绑定的，是根据引用的类型来决定调用哪个方法。
2. 成员变量的隐藏
当子类继承了父类，在子类中声明了与父类具有相同名称的成员变量时，那么就说子类隐藏了父类中的成员变量。子类不能重写父类中的成员变量，只能隐藏。
所以，不管是静态变量还是实例变量，打印的是父类还是子类的成员变量取决于引用的类型，而不是对象的类型，因为子类隐藏了父类的成员变量。
public class JavaTest {
public static void main(String[] args) {
SuperClass superTest = new ThisClass();
System.out.println(superTest.min);
System.out.println(superTest.max);
System.out.println("===================");
ThisClass thisTest = (ThisClass)superTest;
System.out.println(thisTest.min);
System.out.println(thisTest.max);
}
}
class ThisClass extends SuperClass {
public static int max = 8;
public int min = 7;
}
class SuperClass {
public static int max = 4;
public int min = 5;
}
结果如下：
5 4 =================== 7 8
3. 成员变量的继承
如果子类继承了父类的实例变量，子类将与父类共享该实例变量，在子类中修改将影响到父类，反之亦然。
public class JavaTest {
public static void main(String[] args) {
ThisClass superTest = new ThisClass();
System.out.println("修改之前：");
superTest.printMin();
System.out.println("修改子类之后：");
superTest.setMin(4);
superTest.printMin();
System.out.println("修改父类之后：");
superTest.setSuperMin(7);
superTest.printMin();
}
}
class ThisClass extends SuperClass {
public void setMin(int value) {
min = value;
}
public void setSuperMin(int value) {
super.min = value;
}
public void printMin() {
System.out.println("父类的min: " + super.min);
System.out.println("子类的min: " + min);
}
}
class SuperClass {
public int min = 5;
}
结果如下：
修改之前： 父类的min: 5 子类的min: 5 修改子类之后： 父类的min: 4 子类的min: 4 修改父类之后： 父类的min: 7 子类的min: 7
至于静态成员变量就不举例了，静态成员变量和实例变量类似，但实例变量是基于对象的，即每一个对象中子类与父类都共享同一份实例对象的拷贝，而不同的对象互不干扰。而静态成员变量是基于类的，这将会导致所有子类与父类都共享同一个静态变量，无论创建多少对象，都是同一份拷贝。
总结：Java的重写与隐藏其实差不多，最根本的区别就是重写可以实现多态，而隐藏则无法实现多态。
参考自：《细说Java》