Java静态方法:创建当前类型的对象

Java静态方法:创建当前类型的对象,java,class,inheritance,static,Java,Class,Inheritance,Static,我有一个从中继承的抽象类类型来创建新类。作为一个等效示例,请考虑: public abstract class BaseClass { public BaseClass(String input) { ... } public abstract void doSomething(); public String getResult() { ... } } 现在我可以重写基类并实现“doSomething”来

我有一个从中继承的抽象类类型来创建新类。作为一个等效示例,请考虑:

public abstract class BaseClass {
    public BaseClass(String input)
    {
        ...
    }
    public abstract void doSomething();
    public String getResult()
    {
        ...
    }
}
现在我可以重写基类并实现“doSomething”来执行不同的操作(例如,如果我真的在使用字符串,那么可以使用reverse或capitalize,尽管我不是真的,但这只是一个示例)

最常见的用法是:

BaseClass bc = new ExtendsBaseClass(input);
bc.doSomething();
String result = bc.getResult()
因此,我想为此创建一个静态包装器方法。
我想实施:

public static String doSomethingForResult(String input)
{
     BaseClass bc = /*new current type*/;
     bc.doSomething();
     return bc.getResult();
}

但我不知道该用什么来取代这一评论,也不知道如何让它发挥作用;我不想强迫每个实现类都重新实现它(如果这在概念上是可能的,因为不允许使用抽象静态方法。

静态方法不是多态的,因此不能被继承和重写。你想做的是不可能的。

静态方法不是多态的,因此不能被继承和重写。你想做的是不可能的。

为什么在这种情况下,你会为静态的东西烦恼吗

只需从多态性中获益,并合并
doSomething()
getResult()

你最终会得到:

public abstract class BaseClass {
    public BaseClass(String input)
    {
        ...
    }
    public abstract String doSomething();
}
你的客户看起来像:

BaseClass bc = new ExtendsBaseClass(input);
String result = bc.doSomething();
通常,定义一个分离的
getResult()
方法在实现Builder模式等特定情况下是有意义的。实际上,有几个不同的方法参与对象构造,并最终调用一种
getResult()
方法

--------------在您的评论之后--------------------

如您所说,如果常见的情况是使用
doSomething()
后跟
getResult()
,并且根据特定的子类,您可以使用模板方法模式:

public abstract class BaseClass {
        public BaseClass(String input)
        {
          // assigments
        }

        public String process(){ //process is a template method
         doSomething();
         return getResult();
        }

        protected abstract void doSomething();

        protected abstract String getResult();
}

public class ExtendedClass extends BaseClass {

   protected void doSomething(){
     //...
   }

   protected String getResult(){
     //....
   }
}
您的客户端只会调用
process()
方法:

BaseClass bc = new ExtendsBaseClass(input);
String result = bc.process();

但是请:),尽可能避免静态的东西,它们不会导致一个好的面向对象编程。

在这种情况下,为什么要处理静态的东西

只需从多态性中获益,并合并
doSomething()
getResult()

你最终会得到:

public abstract class BaseClass {
    public BaseClass(String input)
    {
        ...
    }
    public abstract String doSomething();
}
你的客户看起来像:

BaseClass bc = new ExtendsBaseClass(input);
String result = bc.doSomething();
通常,定义一个分离的
getResult()
方法在实现Builder模式等特定情况下是有意义的。实际上,有几个不同的方法参与对象构造,并最终调用一种
getResult()
方法

--------------在您的评论之后--------------------

如您所说,如果常见的情况是使用
doSomething()
后跟
getResult()
,并且根据特定的子类,您可以使用模板方法模式:

public abstract class BaseClass {
        public BaseClass(String input)
        {
          // assigments
        }

        public String process(){ //process is a template method
         doSomething();
         return getResult();
        }

        protected abstract void doSomething();

        protected abstract String getResult();
}

public class ExtendedClass extends BaseClass {

   protected void doSomething(){
     //...
   }

   protected String getResult(){
     //....
   }
}
您的客户端只会调用
process()
方法:

BaseClass bc = new ExtendsBaseClass(input);
String result = bc.process();

但是请:),尽可能避免静态的东西,它们不会导致良好的OO编程。

我认为您可以在
基类中定义一个静态方法,并使用
基类
作为参数类将另一个类作为参数传递给它

public static String doSomethingForResult(String input ,BaseClass bc){
    bc.doSomething();
    return bc.getResult();
}
然后在
ExtendedBaseClass
中,您可以编写为:

    ExtendedBaseClass extendedBaseObject= new ExtendedBaseClass();
    String result = BaseClass.doSomethingForResult("input", extendedBaseObject);
    System.out.println(result);

我认为您可以在
BaseClass
中定义一个静态方法,并使用
BaseClass
作为参数类将另一个类作为参数传递给它

public static String doSomethingForResult(String input ,BaseClass bc){
    bc.doSomething();
    return bc.getResult();
}
然后在
ExtendedBaseClass
中,您可以编写为:

    ExtendedBaseClass extendedBaseObject= new ExtendedBaseClass();
    String result = BaseClass.doSomethingForResult("input", extendedBaseObject);
    System.out.println(result);
因此,我想为此创建一个静态包装器方法

我想我明白你为什么要这么做了。您需要一个简单的方法来执行一组常见的操作,而不必一次又一次地复制样板代码。但正如您现在痛苦地意识到的,静态方法在继承层次结构中没有位置。我建议您从各种apachecommons项目及其XxxUtils类中获得灵感,这些类完全由静态方法组成,并且完全存在于它们所作用的类的层次结构之外

以课堂为例。这只是静态方法,但它们非常有用。考虑两种方法:

static byte[] readFileToByteArray(File file) // Reads the contents of a file into a byte array.
static String readFileToString(File file) // Reads the contents of a file into a String
一个方法处理文件和字节数组,另一个处理文件和字符串?你怎么知道哪个做什么-因为它使用一个描述性的名称来拼写它。没有继承、实现和多态性问题,因为FileUtils完全存在于文件、字符串、字节数组等的继承层次结构之外

让我们回到你假设的方法。我将把这个方法放在一个名为MyUtils或BitmapUtils的单独类中,并为每个有意义的具体类组合创建一个方法

public static String doSomethingWithExtendsBaseClass(String input)
{
     BaseClass bc = new ExtendsBaseClass();
     bc.doSomething();
     return bc.getResult();
}

public static String doSomethingWithOtherClass(String input)
{
     BaseClass bc = new OtherClass();
     bc.doSomething();
     return bc.getResult();
}
但我不知道该用什么来取代这个评论,也不知道如何让它发挥作用

简单-您只需直接在方法中用相应的名称实例化具体类

因此,我想为此创建一个静态包装器方法

我想我明白你为什么要这么做了。您需要一个简单的方法来执行一组常见的操作,而不必一次又一次地复制样板代码。但正如您现在痛苦地意识到的,静态方法在继承层次结构中没有位置。我建议您从各种apachecommons项目及其XxxUtils类中获得灵感,这些类完全由静态方法组成,并且完全存在于它们所作用的类的层次结构之外

以课堂为例。这只是静态方法,但它们非常有用。考虑两种方法:

static byte[] readFileToByteArray(File file) // Reads the contents of a file into a byte array.
static String readFileToString(File file) // Reads the contents of a file into a String
一个方法处理文件和字节数组,另一个处理文件和字符串?你怎么知道哪个做什么-因为它使用一个描述性的名称来拼写它。没有继承、实现和多态性问题,因为FileUtils完全存在于文件、字符串、字节数组等的继承层次结构之外

让我们回到你假设的方法。我会把这个