我想知道：
答案 0 :(得分：73)
静态方法无法在单词的确切意义上被覆盖，但它们可以隐藏父静态方法
实际上，这意味着que编译器将决定在编译时执行哪个方法，而不是在运行时，就像重写实例方法一样。
对于一个简洁的例子看看here。
this是java文档，用于解释重写实例方法与隐藏类（静态）方法之间的区别。
覆盖：在Java中覆盖只是意味着将根据对象的运行时类型调用特定方法， 不是它的编译时类型（覆盖的情况就是这种情况） 静态方法）
隐藏：静态的父类方法不是子类的一部分（虽然它们是可访问的），所以没有问题 压倒它。即使在子类中添加另一个静态方法， 与其父类中的一个相同，这个子类是静态方法 是唯一的，与其父类中的静态方法不同。
答案 1 :(得分：25)
无法覆盖静态方法，因为没有什么可以覆盖，因为它们是两种不同的方法。例如
static class Class1 {
public static int Method1(){
return 0;
}
}
static class Class2 extends Class1 {
public static int Method1(){
return 1;
}
}
public static class Main {
public static void main(String[] args){
//Must explicitly chose Method1 from Class1 or Class2
Class1.Method1();
Class2.Method1();
}
}
是的静态方法可以像任何其他方法一样重载。
答案 2 :(得分：9)
无法覆盖静态方法，因为它们在运行时未在对象实例上调度。编译器决定调用哪个方法。
这就是您在编写
时收到编译器警告的原因 MyClass myObject = new MyClass();
myObject.myStaticMethod();
// should be written as
MyClass.myStaticMethod()
// because it is not dispatched on myObject
myObject = new MySubClass();
myObject.myStaticMethod();
// still calls the static method in MyClass, NOT in MySubClass
静态方法可以重载（这意味着只要它们具有不同的参数类型，您就可以为多个方法使用相同的方法名称。）
Integer.parseInt("10");
Integer.parseInt("AA", 16);
答案 3 :(得分：6)
静态的父类方法不是子类的一部分（尽管它们是可访问的），因此不存在覆盖它的问题。即使在子类中添加另一个静态方法，与其父类中的静态方法相同，此子类静态方法也是唯一的，与其父类中的静态方法不同。
答案 4 :(得分：4)
无法覆盖静态方法，因为它们不是对象状态的一部分。相反，它们属于类（即它们是类方法）。可以重载静态（和最终）方法。
答案 5 :(得分：3)
如果我通过使用SubClass名称MysubClass调用该方法，那么子类方法显示它意味着静态方法可以被覆盖或不是
class MyClass {
static void myStaticMethod() {
System.out.println("Im in sta1");
}
}
class MySubClass extends MyClass {
static void myStaticMethod() {
System.out.println("Im in sta123");
}
}
public class My {
public static void main(String arg[]) {
MyClass myObject = new MyClass();
myObject.myStaticMethod();
// should be written as
MyClass.myStaticMethod();
// calling from subclass name
MySubClass.myStaticMethod();
myObject = new MySubClass();
myObject.myStaticMethod();
// still calls the static method in MyClass, NOT in MySubClass
}
}
答案 6 :(得分：3)
静态方法是一种方法，其单个副本由类的所有对象共享。静态方法属于类而不是对象。因为静态方法不依赖于对象，Java编译器不需要等到对象创建。所以调用静态方法我们使用类似ClassName.method（）的语法;
在方法重载的情况下，方法应该在同一个类中进行重载。即使它们被声明为静态，也可以将它们重载为，
Class Sample
{
static int calculate(int a,int b,int c)
{
int res = a+b+c;
return res;
}
static int calculate(int a,int b)
{
int res = a*b;
return res;
}
}
class Test
{
public static void main(String []args)
{
int res = Sample.calculate(10,20,30);
}
}
但是在方法覆盖的情况下，超类中的方法和子类中的方法充当不同的方法。超类将拥有自己的副本，子类将拥有自己的副本，因此它不受方法覆盖。
答案 7 :(得分：2)
不，静态方法不能被覆盖，因为它是类的一部分而不是对象。 但是可以超载静态方法。
答案 8 :(得分：2)
答案 9 :(得分：1)
重载也称为静态绑定，因此一旦使用静态一词，就意味着静态方法无法显示运行时多态性。
我们无法覆盖静态方法 ，但是在超类及其子类中存在相同静态方法的不同实现是有效的。只是派生类将隐藏基类的实现。
对于静态方法，方法调用取决于引用的类型，而不取决于所引用的对象，即，静态方法仅属于类而不是其实例，因此，方法调用是在编译时自己决定的。 / p>
在方法重载的情况下 静态方法可以重载 iff ，它们具有diff数量或参数类型。如果两个方法具有相同的名称和相同的参数列表，则只能使用'static'关键字将它们定义为不同。
答案 10 :(得分：1)
来自Why doesn't Java allow overriding of static methods?
覆盖取决于拥有一个类的实例。多态性的一点是，您可以对类进行子类化，并且实现这些子类的对象将对超类中定义的相同方法具有不同的行为（并在子类中重写）。静态方法与类的任何实例都没有关联，因此该概念不适用。
推动Java设计的两个因素影响了这一点。一个是对性能的担忧：有很多批评Smalltalk关于它太慢（垃圾收集和多态调用是其中的一部分）而Java的创建者决心避免这种情况。另一个决定是Java的目标受众是C ++开发人员。使静态方法的工作方式与C ++程序员熟悉，并且速度非常快，因为不需要等到运行时才能找出要调用的方法。
答案 11 :(得分：1)
class SuperType {
public static void classMethod(){
System.out.println("Super type class method");
}
public void instancemethod(){
System.out.println("Super Type instance method");
}
}
public class SubType extends SuperType{
public static void classMethod(){
System.out.println("Sub type class method");
}
public void instancemethod(){
System.out.println("Sub Type instance method");
}
public static void main(String args[]){
SubType s=new SubType();
SuperType su=s;
SuperType.classMethod();// Prints.....Super type class method
su.classMethod(); //Prints.....Super type class method
SubType.classMethod(); //Prints.....Sub type class method
}
}
静态方法覆盖的示例
注意：如果我们用对象引用调用静态方法，那么将调用引用类型（类）静态方法，而不是对象类静态方法。
静态方法仅属于类。
答案 12 :(得分：0)
您可以重载静态方法，但不能覆盖静态方法。实际上，您可以在子类中重写静态方法，但这不会被称为覆盖，因为覆盖应该与多态和动态绑定相关。静态方法属于类，因此与这些概念无关。静态方法的重写更像是一个阴影。
答案 13 :(得分：0)
由于任何静态方法都是类而非实例的一部分，因此无法覆盖静态方法
答案 14 :(得分：0)
实际上很容易理解 - 所有标记为static的东西都只属于类，例如静态方法不能在子类中继承，因为它们属于声明它们的类。请参阅静态关键字。
我发现这个问题的最佳答案是：
<强> http://www.geeksforgeeks.org/can-we-overload-or-override-static-methods-in-java/
答案 15 :(得分：0)
我设计了一个静态方法覆盖的代码。我认为它很容易覆盖。请告诉我它是如何无法覆盖静态成员的。这是我的代码 -
class Class1 {
public static int Method1(){
System.out.println("true");
return 0;
}
}
class Class2 extends Class1 {
public static int Method1(){
System.out.println("false");
return 1;
}
}
public class Mai {
public static void main(String[] args){
Class2 c=new Class2();
//Must explicitly chose Method1 from Class1 or Class2
//Class1.Method1();
c.Method1();
}
}
答案 16 :(得分：0)
不，你不能覆盖静态方法。静态解析类，而不是实例。
public class Parent {
public static String getCName() {
return "I am the parent";
}
}
public class Child extends Parent {
public static String getCName() {
return "I am the child";
}
}
每个类都有一个静态方法getCName（）。当您调用类名时，它的行为与您期望的一样，并且每个都返回预期值。
@Test
public void testGetCNameOnClass() {
assertThat(Parent.getCName(), is("I am the parent"));
assertThat(Child.getCName(), is("I am the child"));
}
这个单元测试没有惊喜。但这并不是最重要的。这声明了一个名称冲突的东西。
如果我们尝试从类的实例中获取静态（不是一个好习惯），那么它确实显示：
private Parent cp = new Child();
`enter code here`
assertThat(cp.getCName(), is("I am the parent"));
即使cp是Child，静态也是通过声明的类型Parent来解析的，而不是对象的实际类型。对于非静态，这是正确解析的，因为非静态方法可以覆盖其父级的方法。
答案 17 :(得分：0)
使用静态方法的目的是访问类的方法而不为它创建实例。如果我们覆盖该方法将没有意义，因为它们将被classname.method（）访问
答案 18 :(得分：-1)
当然，我们不能覆盖Java中的静态方法。 因为JVM在运行时通过使用Java中的动态绑定来基于对象解析正确的重写方法。
但是，Java中的静态方法与Class而不是对象相关联，并且在编译时进行了解析和绑定。