首先，无关重载。
注：重载是同一个类的各个函数之间的。重写是父类子类之间的。Overload和Overwrite的区别。
这里主要谈的是函数重写与隐藏
首先，我的理解：重写和隐藏是互斥的、相对的。父子中都存在的函数，不是重写就是隐藏。
重写和隐藏的本质区别是：重写是动态绑定的，根据运行时引用所指向对象的实际类型来决定调用相关类的成员。而隐藏是静态绑定的，根据编译时引用的静态类型来决定调用的相关成员。换句话说，如果子类重写了父类的方法，当父类的引用指向子类对象时，通过父类的引用调用的是子类方法。如果子类隐藏了父类的方法（成员变量），通过父类的引用调用的仍是父类的方法（成员变量）。
（注：这一句话非常绕，说的是子类隐藏了父类的方法，但调用的还是父类的方法，还不如说是父类隐藏了子类的方法。其实原义是，是针对子类引用说的隐藏，指的是子类引用调用子类，不调用父类；而父类引用仍然调用父类）
Java的隐藏和C++的隐藏是有区别的。也不能说完全不同，但是覆盖面和默认采用方式不同。
先说Java的隐藏（参考 Link）
覆盖则指的是父类引用指向了子类对象，调用的时候会调用子类的具体方法;
隐藏指的是“子类把父类的属性或者方法隐藏了”，即将子类强制转换成父类后，调用的还是父类的属性和方法。（引号内的容易引起歧义，可以忽略） (1) 变量只能被隐藏(包括静态和非静态)，不能被覆盖 (2) 可以用子类的静态变量隐藏父类的静态变量，也可以用子类的非静态变量隐藏父类的静态变量，也可以用非最终变量(final)隐藏父类中的最终变量； (3) 静态方法(static)只能被隐藏，不能被覆盖； (4) 非静态方法可以被覆盖； (5) 不能用子类的静态方法隐藏父类中的非静态方法，否则编译会报错； (6) 不能用子类的非静态方法覆盖父类的静态方法，否则编译会报错； (7) 不能重写父类中的最终方法(final)； (8) 抽象方法必须在具体类中被覆盖；
简单讲，父类和子类的方法的静态性必须一样。要么都有static，要么都没有，否则会报错，已实验。
实例，我在Intellij上面实验了，如下：
package com.company;
class Solution {
}
class SuperClass {
public static int i = 1;
public int j = 2;
public final int k = 3;
public static void method1() {
System.out.println("SuperClass Method1");
}
public void method2() {
System.out.println("SuperClass Method2");
}
public final void method3() {
System.out.println("SuperClass Method3");
}
}
class SubClass extends SuperClass {
public static int i = 2;//无论是不是static，都能隐藏父类的变量i
public static int j = 1;
public final int k = 4;//无论是不是final，都能隐藏父类的变量k
public static void method1() {
System.out.println("SubClass Method1");
}
public void method2() {
System.out.println("SubClass Method2");
}
/*public final void method3() {
System.out.println("SuperClass Method3");
}*/
}
public class Main {
public static void main(String[] args) throws InterruptedException {
SuperClass sc = new SubClass();
System.out.println("i = " + sc.i); // 所有的成员变量,只能被隐藏
System.out.println("j = " + sc.j);
System.out.println("k = " + sc.k);
sc.method1();//静态方法只能被隐藏
sc.method2();
SubClass subc = new SubClass();
System.out.println("i = " + subc.i);
System.out.println("j = " + subc.j);
System.out.println("k = " + subc.k);
subc.method1();
subc.method2();
// Your Codec object will be instantiated and called as such:
//System.out.printf("ret:%d\n", ret);
System.out.println();
}
}
打印结果：
i = 1 j = 2 k = 3 SuperClass Method1 SubClass Method2 i = 2 j = 1 k = 4 SubClass Method1 SubClass Method2
把上面子类里面变量的static和final去掉：
public int i = 2;//无论是不是static，都能隐藏父类的变量i
public static int j = 1;
public int k = 4;//无论是不是final，都能隐藏父类的变量k
打印的结果和原来的一致：
i = 1 j = 2 k = 3 SuperClass Method1 SubClass Method2 i = 2 j = 1 k = 4 SubClass Method1 SubClass Method2
而C++里面的隐藏，和Java里面的隐藏的语义，不太一样，参考 Link:
如果派生类的函数与基类的函数同名, 但是参数不同. 此时, 不论有无 virtual 关键字, 基类的函数将被隐藏(注意别与重载混淆). 如果派生类的函数与基类的函数同名, 并且参数也相同, 但是基类函数没有 virtual 关键字. 此时, 基类的函数被隐藏(注意别与覆盖混淆).
也就是说，C++的重写，只跟virtual关键字有关。如果没有这个关键字，那么父类中的方法和子类是没有关系的。即使用了virtual，如果方法参数不一样，也不重载，而是采用隐藏。
而Java默认是重载，只有static方法和变量，是不重载，而采用隐藏的。
注：我认为的，对于“隐藏”，好的记忆方法是指向子类实例的父类指针（引用），看到的仍然是父类的方法，而把子类的方法给“隐藏”了。