java中的动态对象创建

我有下面的代码

public class Test {
    public static void main(String args[])
    {
        int i = 0;

        if(i==0){
            Beer obj = new Beer();
        }
        else {
            Rum obj = new Rum();
        }
        System.out.println(obj.brand);  //doesn't work
    } }

class Drink {
} 
class Beer extends Drink{
    public String brand = "BeerBrand"; }

class Rum extends Drink{
    public String brand = "RumBrand"; }

有没有一种方法可以在不使用函数重写或动态类加载的情况下实现上述功能

所有类都是在JVM中动态加载的，没有像C中那样的静态加载。这是正确的吗

---

Drink

应该是一个抽象类，并提供一个抽象成员

getBrand（）

或类似的，由

Beer

和

Rum

覆盖

然后你会这样做：

Drink d = null;
if (...) {
   d = new Beer();
}

if (this instanceof Beer) {
   ...
}

因此，您可以适当地实例化引用。因为它仍然是

饮料类型

您可以参考该品牌。饮料引用将允许您访问任何可以饮用的饮料，实现提供了详细信息。请注意，

饮料

是抽象的，因为您不能实例化

饮料

——您必须更加具体

要回答进一步的问题，您可以提供一个基本方法，并执行以下操作：

Drink d = null;
if (...) {
   d = new Beer();
}

if (this instanceof Beer) {
   ...
}

以避免覆盖。但你为什么要这么做

---

要回答第二个问题，类是由JVM在引用时动态加载的。您可以通过在JVM上设置

-verbose

标志来观察发生的情况。

应该是一个抽象类，并提供一个抽象成员

getBrand（）

或类似的，由

啤酒
和
朗姆酒
覆盖

然后你会这样做：

Drink d = null;
if (...) {
   d = new Beer();
}

if (this instanceof Beer) {
   ...
}

因此，您可以适当地实例化引用。因为它仍然是
饮料类型
您可以参考该品牌。饮料引用将允许您访问任何可以饮用的饮料，实现提供了详细信息。请注意，
饮料
是抽象的，因为您不能实例化
饮料
——您必须更加具体

要回答进一步的问题，您可以提供一个基本方法，并执行以下操作：

Drink d = null;
if (...) {
   d = new Beer();
}

if (this instanceof Beer) {
   ...
}

以避免覆盖。但你为什么要这么做

要回答第二个问题，类是由JVM在引用时动态加载的。您可以通过在JVM上设置
-verbose
标志来观察发生的情况。
此代码不起作用，因为“obj”的作用域仅在if-else块中。
您需要在上面声明类型为Drink的if-else块。
此代码无效，因为“obj”的作用域仅在if-else块中。
您需要在上面声明它，否则将阻止类型为Drink

有没有一种方法可以在不使用函数重写或动态类加载的情况下实现上述功能

唯一的替代方法是使用反射，但是修复类的设计会更简单/更好

所有类都是在JVM中动态加载的，没有像C中那样的静态加载。这是正确的吗

对。它们可以动态加载多次，甚至可以卸载


使用面向对象的方法看起来是这样的

public class Test {
    public static void main(String... args) {
        Drink drink;
        if (args.length == 0) {
            drink = new Beer();
        } else {
            drink = new Rum();
        }
        System.out.println(drink.getBrand());
    }
}

interface Drink {
    public String getBrand();
}

class Beer implements Drink {
    @Override
    public String getBrand() {
        return "BeerBrand"; 
    }
}

class Rum implements Drink {
    @Override
    public String getBrand() {
        return "RumBrand";
    }
}

有没有一种方法可以在不使用函数重写或动态类加载的情况下实现上述功能

唯一的替代方法是使用反射，但是修复类的设计会更简单/更好

所有类都是在JVM中动态加载的，没有像C中那样的静态加载。这是正确的吗

对。它们可以动态加载多次，甚至可以卸载


使用面向对象的方法看起来是这样的

public class Test {
    public static void main(String... args) {
        Drink drink;
        if (args.length == 0) {
            drink = new Beer();
        } else {
            drink = new Rum();
        }
        System.out.println(drink.getBrand());
    }
}

interface Drink {
    public String getBrand();
}

class Beer implements Drink {
    @Override
    public String getBrand() {
        return "BeerBrand"; 
    }
}

class Rum implements Drink {
    @Override
    public String getBrand() {
        return "RumBrand";
    }
}

但在一次采访中，我被问及java中静态类加载和动态类加载之间的区别：p这些都是误用的术语，答案如下：在所有情况下，Java类都是动态加载的，但类名的绑定是静态的（由javac编译确定）或动态的（在运行时确定），但我在采访中被问及Java中静态类加载和动态类加载之间的区别：p这些是误用的术语，其答案与所有情况下动态加载Java类一样，但类名的绑定是静态的（由javac编译确定）或动态的（在运行时确定）