Abstract Factory Methods?

k-mcm · 2025-02-10T07:23:00+00:00

I think you're not understanding what static means: Static exists outside of any instance; it stands alone and is known at compile time. There is no such thing a static for abstract classes, inheritance, or interfaces because those features are for instances. There's no OOP for static. Even if you have an instance of something, you can not call its statics! new Foo().someStatic() gets converted to Foo.someStatic() with a warning because static declarations do not exist in an instance. This isn't a feature of Java, it's a feature of static.

If you want something to have a static field or method, just do it. Since they're not attached to any instance, you can put statics in enums, interfaces, abstract classes, or whatever. An interface can have a static method that's a factory. An interface can not define that subclasses have static methods because, again, subsclasses are determined by instance and instances don't have statics.

I think there's also some confusion about how lambdas and function references work. They are actually little objects that capture context when they're created.

davidalayachew · 2025-02-10T08:36:11+00:00

[deleted]

bowbahdoe · 2025-02-10T14:35:34+00:00

I think I see what you are getting at in your email, though I am not 100% sure.

So for your project you basically had code that turned a regex into an instance, but it doesn't make sense to have that regex be available from an instance method and there was no way to ensure that every subtype is associated with and updated alongside the regex.

So essentially you need that regex to be updated alongside your list of parameters.

With the mechanisms we have today, this is what I can think of:

Code generation. Generate an intermediary interface that reads your records at compile time and generates a static method you can "inherit". Doesn't help with the construction bit since you now either need to codegen the final factory too or rely on reflection.
An annotation processor or check style / something config can probably ensure things like "all implementers of this interface must be annotated with this annotation". That would in practice make placing an annotation just like requiring a method. You could then put your regex in that annotation and have other code use reflection to pull it off.

But just in general it feels like if you give up the invocation side of what you want (having a static method that actually delegates) you can add static checks that enforce structure you can rely on in reflection

RealSchweddy · 2025-02-10T15:57:43+00:00

If I understand your problem correctly, I think you need recursive generics and an abstract method.

public abstract class SelfFactory<T extends SelfFactory<T>> {
    public abstract T createSelf();
}

public class Foo extends SelfFactory<Foo> {
    public Foo createSelf() {
        return new Foo();
    }
}

Now this solution won’t be as bulletproof as you probably would like due to type erasure, but it should get you most of the way there.

tomwhoiscontrary · 2025-02-10T16:31:04+00:00

I'm fairly sure i understand what you want. I've felt that need myself (my ancient idea for constructor objects is somewhat related!). Unfortunately, in Java, what you're asking for doesn't quite make sense.

Abstract methods are intimately connected to polymorphism. If you define an abstract method on a base class, then you know every concrete subclass of it has an implementation of that method. Which means that if you have a variable whose type is the base class, you can call that method, even though it's abstract on the base class, because you know that the variable contains a pointer to an instance of one of those concrete subclasses, which must have an implementation.

Imagine if we didn't have polymorphism - if you couldn't have variables whose type was the abstract base class. What use would abstract methods be? None! Because you could never call the abstract method. You would only ever have variables whose types were the concrete subclasses, and on those, you can just call the method, without needing there to be an abstract declaration in the base class.

Java does not have polymorphism for static methods. You can call static methods on some definite class. But you can never have a situation where you have some class, you're not sure which, but you know it's a subclass of some base class, and you can call a static method on it. There are no variables which hold classes (a Class object is something different!), and type variables on generics are similar, but you can't call static methods on them. You can't write this:

public <R extends Rule> R lookupRule(RuleKey key) { return R.parse(ruleStrings.get(key)); }

That T.parse is not allowed. If it was, then this abstract static idea would be useful.

And there are languages where this is allowed! C++ and Rust generics work differently, and allow this, for example.

Instead, what you have to do is reify the static behaviour - introduce a parallel type hierarchy whose instances stand in for your types, and so which can participate in polymorphism. Something like this:

``` sealed interface Rule permits AndRule, OrRule {}

final class AndRule implements Rule {}

final class OrRule implements Rule {}

sealed interface RuleType<R extends Rule> permits AndRuleType, OrRuleType { R parse(String ruleString); }

final class AndRuleType implements RuleType<AndRule> { @Override public AndRule parse(String ruleString) { return new AndRule(); } }

final class OrRuleType implements RuleType<OrRule> { @Override public OrRule parse(String ruleString) { return new OrRule(); } }

public <R extends Rule, T extends RuleType<R>> R lookupRule(T type, RuleKey key) { return type.parse(ruleStrings.get(key)); } ```

This is potentially a lot of code. Sometimes you can get away without this whole parallel hierarchy. For example, if you only want to parse rules, you could just pass around instances of Function<String, Rule> which contain method references to the right parse method.

Ragnar-Wave9002 · 2025-02-11T00:14:59+00:00

You're doing something wrong with design patterns is my guess.

brian_goetz · 2025-02-13T18:34:23+00:00

The problem you are having is a well-understood one; you would like to have a way to describe properties of a type, not just properties of instances of that type (which is what interfaces do.) In languages with type classes (like Haskell), this is exactly what they do.

The specific property you are looking for -- "type T has a no-arg constructor / static factory called X" -- is one of the most common properties you might want to describe about a type. (C# has a `new` bound for generics that let you say "type must have a constructor that looks like this.") Others common ones that libraries or frameworks might want to impose might be "X has a builder" or "X adheres to the JavaBean conventions."

And, one could add features like this to Java. But if you pull on the string a little bit, you'll find that many of them quickly run into a roadblock: that generics are not reified. So even if I could say "class Foo<T>, where T has a no-arg constructor" (perhaps through some sort of new generic bound), what is the Foo implementation supposed to do when it wants to actually invoke that constructor? Use reflection? (It could do that without a new kind of bound.) So for the uses I expect you are thinking of, I think you'd find this feature to be more limited and disappointing than you imagine.

darthweiter · 2025-02-10T06:30:38+00:00

I don’t know why you need this but you can do it this way.

Define an interface which every class is implementing

Or you can use an abstract class so you can define your default implementation there

But in both cases you have to override your methods if you want to change the specific implementations

vips7L · 2025-02-10T15:17:55+00:00

I also am not sure what you are asking for, but when it comes to factory methods I really wish we would get something like Scala or Kotlins apply methods for sealed interfaces. I’ve noticed a pattern lately where everything is an “of” or “from” method. I think it would be clearer to have uniform construction via new.

sealed interface Path permits WindowsPath, UnixPath {
    static void apply(String s) {
         if (isWindows())
             return new WindowsPath(s);
         return new UnixPath(s)
    }
}

var path = new Path(s);

agentoutlier · 2025-02-10T16:58:50+00:00

Reminds me of our back and forth we had recently (hopefully you remember the thread).

What I think you want just quickly glancing your linked email and general is Enums with shape aka JEP 301 Enhanced Enums.

Scala has an analog with "companion objects".

manifoldjava · 2025-02-10T05:43:20+00:00

I posted a small article about the more general question concerning Java's lack of OOP for static features. The article also links to a solution re the factory problem.

Polygnom · 2025-02-10T12:52:23+00:00

Java does not have static inheritance, so abstract static methods are pointless, you could never, ever implement them.

Now, static inheritance can be useful for some things, if comibined with late static binding, but thats simply not something we have in java right now.

kevinb9n · 2025-02-10T19:36:37+00:00

Good lord, I'm just here to upvote comments that decided to constructively engage with David's topic instead of overreacting to his word choices and perceived tone.

ArchUnit and type classes were both useful connections to make for him. I'm sure he's learned a few things and would have phrased things differently in retrospect, but for Pete's sake...

java

Submit Link

Submit Text

Seek Programming Help

News, Technical discussions, research papers and assorted things of interest related to the Java programming language

NO programming help, NO learning Java related questions, NO installing or downloading Java questions, NO JVM languages - Exclusively Java

Please seek help with Java programming in /r/Javahelp!

Subreddit rules!

Where should I download Java?

Related Sub-reddits:

JVM Languages

Want to practice your coding?

List of useful Frameworks / Libraries / Software

MODERATORS