java静态绑定和多态性

我对下面的静态绑定示例感到困惑。我认为

S2.x

和

S2.y

在根据

S2

的静态类型打印字段时显示静态绑定。并且

S2.foo（）

使得

S2

在超类中调用

foo

方法，因为

foo

在子类中没有过度使用

然而，对于

S2.goo（）

，它不应该调用

Test1

子类中的

goo（）

方法吗？好像是多态性？为什么是静态绑定？它看起来像是

S2.goo（）

调用超类

goo（）

方法并打印出

=13

。非常感谢您的帮助

public class SuperClass {
  public int x = 10; 
  static int y = 10; 
protected SuperClass() { 
     x = y++; 
 } 
 public int foo() { 
     return x; 
 } 
 public static int goo() { 
     return y; 
 } 
}

和子类

public class Test1 extends SuperClass {
 static int x = 15;
 static int y = 15;
 int x2= 20; 
 static int y2 = 20; 

 Test1() 
 { 
     x2 = y2++; 
 } 
 public int foo2() { 
     return x2; 
 } 
 public static int goo2() { 
     return y2; 
 } 

public static int goo(){
     return y2;
 }

public static void main(String[] args) {

    SuperClass s1 = new SuperClass();
    SuperClass s2 = new Test1();
    Test1 t1 = new Test1();

    System.out.println("S2.x = " + s2.x); 
    System.out.println("S2.y = " + s2.y); 
    System.out.println("S2.foo() = " + s2.foo()); 
    System.out.println("S2.goo() = " + s2.goo());
 }
}

---

在Java中，静态变量和方法不是多态的。您不能期望静态字段具有多态行为。

在Java中，静态变量和方法不是多态的。您不能期望静态字段具有多态行为。

在Java中，静态变量和方法不是多态的。您不能期望静态字段具有多态行为。

在Java中，静态变量和方法不是多态的。静态字段不能出现多态行为。

静态方法不能被重写，因为它们在编译时与类绑定。 但是，您可以像这样隐藏类的静态行为：

public class Animal {
   public static void foo() {
    System.out.println("Animal");
   }

    public static void main(String[] args) {
       Animal.foo(); // prints Animal
       Cat.foo(); // prints Cat
    }
}

class Cat extends Animal {
   public static void foo() {  // hides Animal.foo()
     System.out.println("Cat");
   }
} 

输出：

Animal
Cat

请参阅Java中隐藏的方法。

---

另外，注意不要在实例上调用静态方法，因为它们绑定到类本身。

静态方法不能被重写，因为它们在编译时绑定到类本身。 但是，您可以像这样隐藏类的静态行为：

public class Animal {
   public static void foo() {
    System.out.println("Animal");
   }

    public static void main(String[] args) {
       Animal.foo(); // prints Animal
       Cat.foo(); // prints Cat
    }
}

class Cat extends Animal {
   public static void foo() {  // hides Animal.foo()
     System.out.println("Cat");
   }
} 

输出：

Animal
Cat

请参阅Java中隐藏的方法。

---

另外，注意不要在实例上调用静态方法，因为它们绑定到类本身。

静态方法不能被重写，因为它们在编译时绑定到类本身。 但是，您可以像这样隐藏类的静态行为：

public class Animal {
   public static void foo() {
    System.out.println("Animal");
   }

    public static void main(String[] args) {
       Animal.foo(); // prints Animal
       Cat.foo(); // prints Cat
    }
}

class Cat extends Animal {
   public static void foo() {  // hides Animal.foo()
     System.out.println("Cat");
   }
} 

输出：

Animal
Cat

请参阅Java中隐藏的方法。

---

另外，注意不要在实例上调用静态方法，因为它们绑定到类本身。

静态方法不能被重写，因为它们在编译时绑定到类本身。 但是，您可以像这样隐藏类的静态行为：

public class Animal {
   public static void foo() {
    System.out.println("Animal");
   }

    public static void main(String[] args) {
       Animal.foo(); // prints Animal
       Cat.foo(); // prints Cat
    }
}

class Cat extends Animal {
   public static void foo() {  // hides Animal.foo()
     System.out.println("Cat");
   }
} 

输出：

Animal
Cat

请参阅Java中隐藏的方法。

---

另外，注意不要在实例绑定到类本身时调用静态方法。

添加到此调用s2.goo（）中不是对对象的调用，而是对s2引用的类变量（超类）的调用。因此，不管要添加到调用s2的底层对象是什么，都会有效地调用超类方法。goo（）不是对对象的调用，而是对s2引用的类变量（即超类）的调用。因此，不管要添加到调用s2的底层对象是什么，都会有效地调用超类方法。goo（）不是对对象的调用，而是对s2引用的类变量（即超类）的调用。因此，不管要添加到调用s2的底层对象是什么，都会有效地调用超类方法。goo（）不是对对象的调用，而是对s2引用的类变量（即超类）的调用。因此，不管底层对象是什么，都可以有效地调用超类方法。谢谢那么静态方法是根据变量的静态类型调用的？我的意思是，在你的例子中，如果我们创建animalmonster=newcat（），那么monster.foo（）仍然会打印出“Animal”？Sweet。谢谢那么静态方法是根据变量的静态类型调用的？我的意思是，在你的例子中，如果我们创建animalmonster=newcat（），那么monster.foo（）仍然会打印出“Animal”？Sweet。谢谢那么静态方法是根据变量的静态类型调用的？我的意思是，在你的例子中，如果我们创建animalmonster=newcat（），那么monster.foo（）仍然会打印出“Animal”？Sweet。谢谢那么静态方法是根据变量的静态类型调用的？我的意思是，在你的例子中，如果我们创建animalmonster=newcat（），那么monster.foo（）仍然会打印出“Animal”？