主页 / 问题 / 1561650
Accepted
Qwer
Asked:2024-01-15 04:30:00 +0000 UTC2024-01-15 04:30:00 +0000 UTC

父类和子类中的静态方法

  • 772

有一段代码：

public class Coffee {
    String name="Кофе";

    public static void buyCoffee(Coffee coffee) {
        System.out.println("Вы купили " + coffee.name);
    }
}

public class Latte extends Coffee{
    String name = "Латте";

    public static void buyCoffee(Coffee coffee) {
        System.out.println("Вы купили " + coffee.name);
    }
}

import static filosofia.java.p212.inheritance.static_method.Latte.buyCoffee;

public class Main {
    public static void main(String[] args) {
      
        Latte latte = new Latte();
        buyCoffee(latte);
    }
}

产生以下结果

Вы купили Кофе

我知道静态方法不支持多态行为，因此需要Вы купили Кофе对象的输出。Coffee coffee = new Latte()但为什么Latte latte = new Latte()它对 java 对象的反应就像它是 Coffee 类型的对象一样，尚不清楚。那些。如果没有创建该类的实例，Coffee程序仍将访问其字段。怎么会这样？

java

2 个回答

  1. Best Answer

    类字段不能被覆盖，只能覆盖实例方法。

    由于父类Coffee和子类都Latte定义了具有相同名称的字段，因此直接访问该字段（无需虚拟 getter）将返回与该实例的引用类型name匹配的值。也就是说，变量将从方法参数中指定类型的类中获取，而不是从其引用的类型中获取。name

    那些。如果没有创建该类的实例，Coffee程序仍将访问其字段

    当调用构造函数时，new Latte()将调用父类的默认构造函数new Coffee()，这将“创建”父类的字段，该字段将通过引用类型进行访问：

    new Latte() 
    -> new Coffee() 
       {name = "Coffee"}
{name = "Latte"}

    要显示名称，Latte您需要“重载”该方法，以便它接受类型的参数Latte：

    class Coffee {
    String name = "Кофе";
    
    public static void buyCoffee(Coffee coffee) {
        System.out.println("Coffee: Вы купили " + coffee.name);
    }
}

class Latte extends Coffee {
    String name = "Латте"; // скрывает поле в классе-родителе

    public static void buyCoffee(Coffee coffee) {
        System.out.println("Latte: coffee: Вы купили " + coffee.name);
    }
    
    public static void buyCoffee(Latte latte) {
        System.out.println("Latte: latte: Вы купили " + latte.name);
    }
}

    测试：

    Coffee coffee = new Coffee();
Latte.buyCoffee(coffee);       // buyCoffee(Coffee)

Coffee coffeeLatte = new Latte();
Latte.buyCoffee(coffeeLatte);  // buyCoffee(Coffee)

Latte latte = new Latte();
Latte.buyCoffee(latte);        // buyCoffee(Latte)

    结果

    Latte: coffee: Вы купили Кофе
Latte: coffee: Вы купили Кофе
Latte: latte: Вы купили Латте
    • 4

  2. 定义重叠变量是基于变量的类型，而不是对象的实际类型。这与方法不同，方法是由实际对象的类型而不是变量的类型决定的。

    由于静态方法的类型从 Latte 更改为 Coffee，因此将调用父类。

    public class Parent {
    String name = "Parent";
}

public class Child extends Parent {
    String name = "Child";
}

Parent parent = new Parent();
Child child = new Child();
Parent childWithTypeParent = new Child();

System.out.println(parent.name); // Parent
System.out.println(child.name); // Child
System.out.println(childWithTypeParent.name); // Parent

    因此，将代码更改为

    public class Latte extends Coffee{
    String name = "Латте";

    public static void buyCoffee(Latte latte) {
        System.out.println("Вы купили " + latte.name);
    }
}

    您将得到输出“您买了一杯拿铁”。

    • 0

相关问题