在java中实例化子类

我有一个这样的抽象类：

public abstract class MyAbstractClass {

    protected String greeting;

    public void run() {
        doSomething();
    }

    public abstract void doSomething();
}

public class MyClass extends MyAbstractClass {

    public MyClass() {
        this.greeting = "Hello, World!";
    }

    public void doSomething() {
        System.out.println(greeting);
    }

    public static void main(String[] args) {
        MyAbstractClass c = new MyClass();
        c.run();
    }
}

。。。还有这样一个子类：

public abstract class MyAbstractClass {

    protected String greeting;

    public void run() {
        doSomething();
    }

    public abstract void doSomething();
}

public class MyClass extends MyAbstractClass {

    public MyClass() {
        this.greeting = "Hello, World!";
    }

    public void doSomething() {
        System.out.println(greeting);
    }

    public static void main(String[] args) {
        MyAbstractClass c = new MyClass();
        c.run();
    }
}

我将创建多个子类，所有子类都将使用相同的主方法来实例化子类。有没有一种更简洁的方法来编写它，这样我就不需要用不同的子类名称在每个子类中复制main方法了？因此，如果我创建一个名为

MyOtherClass

的新子类，我不需要在

MyAbstractClass c=new MyOtherClass（）中放入main方法

我想我可以反过来做，从抽象类运行main并实例化其中的子类，但是每次我想更改实例化的子类时，我显然需要在
new
之后更改类名。我想我要寻找的是一种在抽象类中定义main方法的方法，当我运行子类时，它会实例化子类的一个副本，而不是抽象类。如果这有道理的话…
这似乎是一个很好的选择。试着这样做：

public abstract class MyAbstractClass {

    protected String greeting;

    public void run() {
        doSomething();
    }

    public abstract void doSomething();

    public abstract MyAbstractClass makeClass();

}

public class MyClass1 extends MyAbstractClass {

    public MyClass1() {
        this.greeting = "Hello, World!";
    }

    @Override
    public void doSomething() {
        System.out.println(greeting);
    }

    @Override
    public MyAbstractClass makeClass() {
        return new MyClass1();
    }

}

public static void main(String[] args) throws Exception {
    String className = args[0];
    MyAbstractClass object = (MyAbstractClass) Class.forName(className).newInstance();
    object.run();
}

然后，当您需要创建一个特定的实例时，只调用一个实现在您认为最方便的地方的<代码>主体（）//>代码> >代码> >，例如在<代码> MyAbstractClass < /代码>：

MyAbstractClass mac = new MyClass1();
MyAbstractClass obj = mac.makeClass();

最后一行将根据用于实例化具体对象的类返回一个适当的实例。
这似乎非常适合于。试着这样做：

public abstract class MyAbstractClass {

    protected String greeting;

    public void run() {
        doSomething();
    }

    public abstract void doSomething();

    public abstract MyAbstractClass makeClass();

}

public class MyClass1 extends MyAbstractClass {

    public MyClass1() {
        this.greeting = "Hello, World!";
    }

    @Override
    public void doSomething() {
        System.out.println(greeting);
    }

    @Override
    public MyAbstractClass makeClass() {
        return new MyClass1();
    }

}

public static void main(String[] args) throws Exception {
    String className = args[0];
    MyAbstractClass object = (MyAbstractClass) Class.forName(className).newInstance();
    object.run();
}

然后，当您需要创建一个特定的实例时，只调用一个实现在您认为最方便的地方的<代码>主体（）//>代码> >代码> >，例如在<代码> MyAbstractClass < /代码>：

MyAbstractClass mac = new MyClass1();
MyAbstractClass obj = mac.makeClass();

最后一行将根据用于实例化具体对象的类返回适当的实例。
这是动态类加载的有用之处。如果您的所有子类都同意使用无参数构造函数，则只需将单个主类与Main方法一起使用，并将该类作为参数传递：

java com.foo.bar.Main com.foo.bar.MyFrouteenthSubclass

java com.foo.bar.Main fourteen

主要方法如下所示：

public abstract class MyAbstractClass {

    protected String greeting;

    public void run() {
        doSomething();
    }

    public abstract void doSomething();

    public abstract MyAbstractClass makeClass();

}

public class MyClass1 extends MyAbstractClass {

    public MyClass1() {
        this.greeting = "Hello, World!";
    }

    @Override
    public void doSomething() {
        System.out.println(greeting);
    }

    @Override
    public MyAbstractClass makeClass() {
        return new MyClass1();
    }

}

public static void main(String[] args) throws Exception {
    String className = args[0];
    MyAbstractClass object = (MyAbstractClass) Class.forName(className).newInstance();
    object.run();
}

您还可以为所有子类指定一个名称，并将每个子类的实例存储在
映射中
，只需使用类的名称作为参数调用主类即可：

java com.foo.bar.Main com.foo.bar.MyFrouteenthSubclass

java com.foo.bar.Main fourteen

这是动态类加载非常有用的地方。如果您的所有子类都同意使用无参数构造函数，则只需将单个主类与Main方法一起使用，并将该类作为参数传递：

java com.foo.bar.Main com.foo.bar.MyFrouteenthSubclass

java com.foo.bar.Main fourteen

主要方法如下所示：

public abstract class MyAbstractClass {

    protected String greeting;

    public void run() {
        doSomething();
    }

    public abstract void doSomething();

    public abstract MyAbstractClass makeClass();

}

public class MyClass1 extends MyAbstractClass {

    public MyClass1() {
        this.greeting = "Hello, World!";
    }

    @Override
    public void doSomething() {
        System.out.println(greeting);
    }

    @Override
    public MyAbstractClass makeClass() {
        return new MyClass1();
    }

}

public static void main(String[] args) throws Exception {
    String className = args[0];
    MyAbstractClass object = (MyAbstractClass) Class.forName(className).newInstance();
    object.run();
}

您还可以为所有子类指定一个名称，并将每个子类的实例存储在
映射中
，只需使用类的名称作为参数调用主类即可：

java com.foo.bar.Main com.foo.bar.MyFrouteenthSubclass

java com.foo.bar.Main fourteen

为什么在每个子类中都需要
main
方法？你知道
main
方法的目的是什么吗？嗯……实际上只有一个
main
运行，所以也许你应该将所有的子类实例化压缩成一个驱动程序类（一个只有
main
的类）？抽象类具有执行I/O等常见操作的功能。每个子类处理输入的方式不同。因此，我将针对特定的输入运行子类。
static
方法不能被重写。它只能重新定义。为什么在每个子类中都需要
main
方法？你知道
main
方法的目的是什么吗？嗯……实际上只有一个
main
运行，所以也许你应该将所有的子类实例化压缩成一个驱动程序类（一个只有
main
的类）？抽象类具有执行I/O等常见操作的功能。每个子类处理输入的方式不同。因此，我将针对特定的输入运行子类。
static
方法不能被重写。它只能被重新定义，我想我想要摆脱的是在每个子类中都有一个通用的方法，它做的事情完全相同，但是子类的名称不同。您的示例只是将问题从
main
转移到
makeClass（）
@conorgriffin是的，它将责任从一个地方转移到另一个地方-但没有逃避，在某些地方需要实例化对象，将此代码放在每个子类中是有意义的；另一方面，Java应用程序只能有一个
main（）
方法，因此有必要去掉多个
main（）
方法。好的，这些子类中的每一个子类都是一个应用程序。它们实际上是解决编程难题的小程序。它们有一些共同的功能，比如读取输入文件和编写输出，所以我将这些功能保留在抽象类中，并将特定于问题的逻辑放在子类中。因此，它们现在都有自己的main，所以我可以在isolation中运行它们。我想我真正想摆脱的是，在每个子类中都有一个通用的方法，它做的事情完全相同，但子类名称不同。您的示例只是将问题从
main
转移到
makeClass（）
@conorgriffin是的，它将责任从一个地方转移到另一个地方-但没有逃避，在某些地方需要实例化对象，将此代码放在每个子类中是有意义的；另一方面，Java应用程序只能有一个
main（）
方法，因此有必要去掉多个
main（）
方法。好的，这些子类中的每一个子类都是一个应用程序。它们实际上是解决编程难题的小程序。它们有一些共同的功能，比如读取输入文件和编写输出，所以我将这些功能保存在抽象类和pu中