CODEWITHSUNDEEP
javainheritancesubclassprogram-entry-pointabstract
Aequitas
Aequitas

Reputation: 2265

How can you declare that all subclasses of an abstract class will implement main?

I have an abstract class called Trader which acts like a client with a server (StockMarket) and I would like to declare in the Trader class that all classes that inherit from it will need to implement a main entry point so that they can be run.

The problem is that if I write:

public static abstract void main(String[] args) throws Exception;

it gives an error that only visibility modifiers are allowed. But if I remove the static modifier then it does not work as a main entry point allowing it to be run.

So how to declare all subclasses of an abstract class must implement a main method?

Upvotes: 1

Views: 829

Answers (5)

Farhan
Farhan

Reputation: 1278

Lets start with the meaning of 

public static void main (String[] args)...

static

means that this method does require an instance of the class (containing this method). Java virtual machine (JVM) states this as a requirement for the entry point of a program, reason being that the class may have multiple constructors or no default constructor and there is no way for JVM to know how to create object of the class.

public

allows the method to be accessible outside the package (and class obviously), so JVM is free to invoke this method.

main

is the name of the method that JVM looks for in the class, since there could be multiple public static methods.

void

returns nothing. This is the part of the signature that JVM looks for as entry point.

Now lets answer your question in light of this information. Polymorphism is relevant to OOP concept of inheritance and interface implementation, and it irrelevant to static methods.

So the only choice you have is to choose 1 'public static void main' method as the entry point based on the 'args', call other public static methods. However, other methods need not have the same signature.

Upvotes: 1

holi-java
holi-java

Reputation: 30696

static method does not supports polymorphism, so you can't declare it as abstract. but you can declaring an abstract class with abstract methods that @MauricePerry has been proposed. I will come up with how to get the Main class?

you can extract the Main class name from the system property sun.java.command.

  1. truncate the args from the command.
  2. second, truncate the IDE Main class name if present.

here is my implementation you can using:

public abstract class Trader {
    protected abstract void run(String... args);

    public static void main(String[] args) throws Exception {
        runAs(getMainClass(args)).run(args);
    }

    private static Trader runAs(Class<?> mainClass)
            throws IllegalAccessException, InstantiationException {
        checking(!Modifier.isAbstract(mainClass.getModifiers())
                , () -> "abstract class can't be run: " + mainClass);
        checking(Trader.class.isAssignableFrom(mainClass)
                , () -> "class is not a " + Trader.class 
                        + " can't be run: " + mainClass);
        return Trader.class.cast(mainClass.newInstance());
    }

    private static void checking(boolean condition, Supplier<String> message) {
        if (!condition) {
            throw new IllegalArgumentException(message.get());
        }
    }

    private static Class<?> getMainClass(String... args)
            throws ClassNotFoundException {
        String command = commandWithoutArgs(args);
        String[] classes = command.split("\\s+");
        return Class.forName(classes[ classes.length - 1]);
    }

    private static String commandWithoutArgs(String[] args) {
        String command = System.getProperty("sun.java.command");
        return command.substring(0, command.length() - argsLength(args)).trim();
    }

    private static int argsLength(String[] args) {
        if (args.length == 0) {
            return 0;
        }
        return Stream.of(args).collect(Collectors.joining(" ")).length() + 1;
    }
}

Example

public class Application extends Trader {
    @Override
    protected void run(String... args) {
        System.out.println("Application");
    }
}

run the Application using command java Application or run it in IDE.

Upvotes: 0

Lakhan Singh
Lakhan Singh

Reputation: 1

To run a program JVM find main method like public static void main(String[] args) abstract is not used with main method

Upvotes: -1

Satish R
Satish R

Reputation: 153

Static methods cannot be abstract.

  1. Static members data are same for all the objects and derived classes.
  2. Static members can't be overridden by derived class.

Since abstract method need to be defined in derived class it can't be static. Remove static and try.

Upvotes: 0

Maurice Perry
Maurice Perry

Reputation: 9648

You can't.

What I would do instead is declare an abstract, non-static method in Trader:

public abstract void run(String[] args) throws Exception;

And then declare a separate main class that would instantiate an instance, and call the run method:

class RunTrader {
    private static final String DEFAULT_CLASS = "...";

    public static void main(String[] args) {
        try {
            String className = System.getProperty("main-trader-class", DEFAULT_CLASS);
            Class<Trader> traderClass = (Class<Trader>)Class.forName(className);
            Trader trader = traderClass.newInstance();
            trader.run(args);
        } catch (Exception e) {
            // handle the exception
        }
    }
}

Upvotes: 1

Related Questions