我可以重写和重载Java中的静态方法吗？
我想知道：
- 为什么不能在Java中重写静态方法？
- Java中可以重载静态方法吗？
静态方法不能从单词的确切意义上被覆盖，但是它们可以隐藏父级静态方法
在实践中，这意味着que编译器将决定在编译时执行哪个方法，而不是在运行时执行，就像重写的实例方法一样。
一个整洁的例子看看这里 。
这是解释覆盖实例方法和隐藏类（静态）方法之间区别的java文档。
覆盖：在Java中重写只是意味着将根据对象的运行时types而不是它的编译时types来调用特定的方法（这是使用overriden静态方法的情况）
隐藏：静态的父类方法不是子类的一部分（尽pipe它们是可访问的），所以不存在覆盖它的问题。 即使在子类中添加另一个静态方法（与其父类中的静态方法相同），此子类的静态方法也是独特的，并且与其父类中的静态方法不同。
静态方法不能被覆盖，因为它们是两种不同的方法。 例如
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(); } } 静态方法可以像任何其他方法一样被重载。
我们可以重载静态方法吗？
答案是肯定的 我们可以有两个或多个名称相同的静态方法，但input参数不同。 例如，考虑下面的Java程序。
public class Test { public static void foo() { System.out.println("Test.foo() called "); } public static void foo(int a) { System.out.println("Test.foo(int) called "); } public static void main(String args[]) { Test.foo(); //Test.foo() called printed Test.foo(10); //Test.foo(int) called printed } }
我们可以重载只有静态关键字不同的方法吗？
我们不能在Java中重载两个方法，只有静态关键字不同（参数个数和参数types相同）。 例如，请参阅以下Java程序。 这种行为在C ++中是相同的。
public class Test { public static void foo() { System.out.println("Test.foo() called "); } public void foo() { // Compiler Error: cannot redefine foo() System.out.println("Test.foo(int) called "); } public static void main(String args[]) { Test.foo(); } }
我们可以重写java中的静态方法吗？
我们可以在子类中声明具有相同签名的静态方法，但不被视为重写，因为不会有任何运行时多态性。 因此，答案是否定的 。
如果一个派生类在基类中定义了一个与静态方法具有相同签名的静态方法，则派生类中的方法将该方法隐藏在基类中。 如果静态方法由派生类重新定义，那么它不是重写。
class Base { // Static method in base class which will be hidden in subclass public static void display() { System.out.println("Static or class method from Base"); } // Non-static method which will be overridden in derived class public void print() { System.out.println("Non-static or Instance method from Base"); } } class Derived extends Base { // This method hides display() in Base public static void display() { System.out.println("Static or class method from Derived"); } // This method overrides print() in Base public void print() { System.out.println("Non-static or Instance method from Derived"); } } public class Test { public static void main(String args[ ]) { Base obj1 = new Derived(); // As per overriding rules this should call to class Derive's static // overridden method. Since static method can not be overridden, it // calls Base's display() obj1.display(); //output -> Static or class method from Base // Here overriding works and Derive's print() is called obj1.print(); //output-> Non-static or Instance method from Derived } }
静态方法不能被覆盖，因为它们不会在运行时在对象实例上分派。 编译器决定调用哪个方法。
这就是为什么当你编写时会得到一个编译器的警告
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
静态方法可以被重载（意味着只要它们具有不同的参数types，就可以为几个方法使用相同的方法名称）。
Integer.parseInt("10"); Integer.parseInt("AA", 16);
父类方法是静态的，不是子类的一部分（尽pipe它们是可访问的），所以不存在覆盖它的问题。 即使在子类中添加另一个静态方法（与其父类中的静态方法相同），此子类的静态方法也是独特的，并且与其父类中的静态方法不同。
静态方法不能被覆盖，因为它们不是对象状态的一部分。 相反，他们属于类（即他们是类方法）。 重载静态（和最终）方法是可以的。
如果我通过使用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 } }
不，静态方法不能被重写，因为它是类的一部分而不是对象。 但是可以重载静态方法。
静态方法是一个方法，其单个副本由类的所有对象共享。 静态方法不属于对象，因为静态方法不依赖于对象，Java编译器不需要等待对象的创build。因此，要调用静态方法，我们使用的语法如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); } }
但是在方法重写的情况下，超类中的方法和子类中的方法作为不同的方法。 超类将有自己的副本，子类将有自己的副本，所以它不会在方法重写。
从Java为什么不允许重写静态方法？
重写取决于有一个类的实例。 多态性的要点是你可以inheritance一个类，实现这些子类的对象对于在超类中定义的相同的方法（在子类中被重写）将具有不同的行为。 一个静态方法不与一个类的任何实例关联，所以这个概念是不适用的。
Java的devise有两个考虑因素影响了这一点。 其中之一就是性能方面的问题：Smalltalk对它的速度太慢了（垃圾收集和多态调用是其中的一部分），Java的创build者决心避免这种情况。 另一个是Java的目标受众是C ++开发者的决定。 使得静态方法的工作方式具有熟悉C ++程序员的好处，而且速度也非常快，因为不需要等到运行时才能确定要调用的方法。
static方法是class级别的方法。
隐藏概念用于static方法。
见： http : //www.coderanch.com/how-to/java/OverridingVsHiding
使用静态方法的目的是为了访问类的方法，而不是为它创build一个实例。如果我们重写那个方法是没有意义的，因为它们将被classname.method（）
不，你不能重写一个静态方法。 静态解决对类，而不是实例。
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")); }
在这个unit testing中没有惊喜。 但是这并不是压倒一切的。这个声明有一个名字相撞的事情。
如果我们试图从一个实例中得到静态（不是一个好习惯），那么它确实表明：
private Parent cp = new Child(); `enter code here` assertThat(cp.getCName(), is("I am the parent"));
即使cp是Child，静态也通过声明的typesParent来parsing，而不是实际的对象types。 对于非静态方法，这是正确解决的，因为非静态方法可以覆盖父类的方法。
你可以重载一个静态方法，但是你不能重写一个静态方法。 实际上，你可以在子类中重写一个静态方法，但是这不是一个重写，因为重写应该和多态和dynamic绑定有关。 静态方法属于类，所以与这些概念无关。 静态方法的重写更像是一个阴影。
我devise了一个静态方法覆盖的代码。我认为它是轻松覆盖。请清楚我如何覆盖静态成员。这里是我的代码 –
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(); } }
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 } }
这个例子用于重写静态方法
注意：如果我们用对象引用调用一个静态方法，那么将调用引用types（类）的静态方法，而不是对象类的静态方法。
静态方法只属于类。
实际上它很容易理解 – 所有标记为静态的东西都只属于类，例如静态方法不能在子类中inheritance，因为它们属于已声明的类。 请参阅static关键字。
我发现这个问题的最佳答案是：
http://www.geeksforgeeks.org/can-we-overload-or-override-static-methods-in-java/
我们可以重载静态方法吗？
答案是'是' 。 我们可以有两个或多个具有相同名称的静态方法，但input参数不同。 例如，考虑下面的Java程序。
// filename Test.java public class Test { public static void foo() { System.out.println("Test.foo() called "); } public static void foo(int a) { System.out.println("Test.foo(int) called "); } public static void main(String args[]) { Test.foo(); Test.foo(10); } }
输出：
Test.foo() called Test.foo(int) called
我们可以重写java中的静态方法吗？
我们可以在子类中声明具有相同签名的静态方法，但不被视为重写，因为不会有任何运行时多态性。 因此答案是“否”。
如果一个派生类在基类中定义了一个与静态方法具有相同签名的静态方法，则派生类中的方法将该方法隐藏在基类中。
/* Java program to show that if static method is redefined by a derived class, then it is not overriding. */ // Superclass class Base { // Static method in base class which will be hidden in subclass public static void display() { System.out.println("Static or class method from Base"); } // Non-static method which will be overridden in derived class public void print() { System.out.println("Non-static or Instance method from Base"); } } // Subclass class Derived extends Base { // This method hides display() in Base public static void display() { System.out.println("Static or class method from Derived"); } // This method overrides print() in Base public void print() { System.out.println("Non-static or Instance method from Derived"); } } // Driver class public class Test { public static void main(String args[ ]) { Base obj1 = new Derived(); // As per overriding rules this should call to class Derive's static // overridden method. Since static method can not be overridden, it // calls Base's display() obj1.display(); // Here overriding works and Derive's print() is called obj1.print(); } }
输出：
Static or class method from Base Non-static or Instance method from Derived
由于任何静态方法是类的一部分而不是实例，所以不可能重载静态方法
是的..实际上…没有理论上……如果你在Java中重写一个静态方法，那么它将编译和运行顺利..但它会失去多态性….这是Java的基本属性..你如果你有Class Animal和一个静态的方法eat（）和你在它的子类中重写了这个静态方法，我们可以把它称为Dog。那么当你将一个Dog对象分配给一个动物引用并且调用eat（）时，根据Java狗的eat（）应该被称为..但是在静态Overriding Animals的eat（）中将会调用..
