Hello World, Phrancis

Question

I just yesterday started learning some Java. I wrote this piece and got some help from @Simon André Forsberg to refine it some. I added a few things since. It's super-simple but I just want to make sure I have a few concepts down before I move on to more complex things. Any constructive criticism is appreciated!

import java.lang.*;

public class HelloWorld {
    private final String output;

    public HelloWorld(String name) {
        output = "Hello World, " + name + "!";
    }

    public String getMessage() {
        return output;
    }

    public static void main (String args[]) {
        HelloWorld helloObj;
        helloObj = new HelloWorld("Phrancis");
        System.out.println(helloObj.getMessage());
    }
}

Console output:

Hello World, Phrancis!

Answer 1

In Java it is seldom necessary to create void variable 'declarations'. The code:

HelloWorld helloObj;
helloObj = new HelloWorld("Phrancis");

should just be:

HelloWorld helloObj = new HelloWorld("Phrancis");

Then, for the actual HelloWorld class, there are a few hints:

1. All Java objects have a toString() method that should, in most cases, be overridden to provide useful diagnostics, or other information. In this case, it would make sense to use the toString() instead of getMessage()
2. You should store data in it's 'raw' form when possible. Your HelloWorld class should store the 'name' and not the 'output'.
3. You should provide getters for internal properties.

I would write the class as:

public class HelloWorld {
    private final String name;

    public HelloWorld(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Hello World, " + name + "!";
    }

}

Then your main method could be:

public static void main (String args[]) {
    HelloWorld helloObj = new HelloWorld("Phrancis");
    System.out.println(helloObj);
}

Answer 2

First things first:

import java.lang.*;

This import is superfluous. Java by default imports the java.lang package, you don't have to specify any further things.

---

You seem to be using consistent two newlines between last } and the next opening brace. I personally find this to take a lot of space and I'd reserve "large" vertical distance to signify sectioning or similar, it's consistent ;)

---

public static void main (String args[]) {

While this is a perfectly valid declaration for main, I'd prefer to have the array declaration behind the type and not behind the argument name for consistency's sake:

public static void main (String[] args) {

Answer 3

Instead of string concatenation, another alternative is using String.format(...) for formatting the message. Combining suggestions from other answers, I'd go with this implementation:

public class HelloWorld {
    private final String message;

    public HelloWorld(String name) {
        this.message = String.format("Hello World, %s!", name);
    }

    @Override
    public String toString() {
        return message;
    }
}

Since name doesn't change, it's good to pre-format the message at construction time, so that toString can simply return it directly.

If you want to access the message directly, you could add a getter for it.

If you want to access the name, you might add a field and a getter for it. But probably a "HelloWorld" object doesn't really need any accessors, does it?

UPDATE

The reason I suggested String.format is because it was not mentioned by other answers, and it's often a useful alternative. It may be a matter of taste, a benefit of this approach is that a template string with placeholders + parameter list can be more readable than concatenation.

As per my discussion in comments with @vaxquis, be aware that the output of String.format may depend on locale, for example when formatting dates and numbers. There is another version of String.format(Locale, String, ...) that takes the Locale as the first parameter to ensure predictable output. (Without this parameter, the default locale is used.) This is especially important in applications intended to run in multiple locales, such as Android apps. For this reason, Android linters flag a warning for uses without a locale parameter.

In this particular example, there are no such concerns, because we're not printing anything locale-sensitive (no dates, numbers). But it's good to be aware of this locale-sensitive behavior in situations where it can make a difference.

Answer 4

private final String output;

I like this. Initializing private fields from constructor arguments, and making them final sounds exactly like The Right Thing™.

public static void main (String args[]) {
    HelloWorld helloObj;
    helloObj = new HelloWorld("Phrancis");
    System.out.println(helloObj.getMessage());
}

This is a bit awkward though: you have written your (static) main method in the HelloWorld class, and then you have that main method create an instance of that very same class - I don't like that.

It's good that you're using objects - creating an instance of a class does that. But I would have implemented the parameterized constructor and the getMessage method in a separate class.

Answer 5

For readability property name and corresponding methods name should be relative.

private final String message; 

public String getMessage() {
    return message;
}

I suggest you to use StringBuilder for String concatenation.

StringBuilder builder = new StringBuilder();
builder.append("Hello").append(name).append("!");
output = builder.toString();