The ugly truth

Alright, let's bring these things together!

In Java, everything we write needs to be in a class.

class SpaceAdventure {
 public static void main 
 (String[] args) {
  String output = "To infinity";
  output += " and beyond!";
  System.out.print(output);
 }
}

//Output Below

To infinity and beyond!

Great! That's why we wrote everything in the class and main() method that we created at the very beginning.

Main

Every Java program needs an entry point, which is what the main() method provides. In order to work, it needs to be in a class and look exactly like this:

class SpaceAdventure {
 public static void main 
 (String[] args) {
  // ...
 }
}

If you've been wondering about what public, static and the args array mean for the past chapters, this chapter is for you.

Another welcome

Whatever we're up to, we need a main() method to pull it off. Take the very beginning:

class MyApp {
 public static void main 
 (String[] args) {
  String greeting = "Hello";
  System.out.print(greeting + " world");
 }
}

//Output Below

Hello world!

None of this would have been possible without main().

Arg(h)s

Before we talk about modifiers, let's have a look at the args array!

In order to work, main() needs to have a string array as a parameter. But why?

class MyApp {
 public static void main 
 (String[] args) {
  System.out.print(args.length);
 }
}

//Output Below

0

As it turns out, we can pass arguments to a program when we launch it, at which point they'll be stored in args. In most cases, however, args will be empty.

Baxter and main

Now that we know about the main() method, let's explore how it connects with classes!

class Playground {
 public static void main 
 (String[] args) {
  Dog myDog = new Dog("Baxter");
  myDog.bark();
 }
}

//Output Below

Woof!

class Dog {
 String name;
 void bark() {
  System.out.print("Woof!");
 }

 Dog(String name) {
  this.name = name;
 }
}

Sweet! We could define both classes in the same .class file but it's a much better idea to add a separateDog.classfile to the project.

Static

Alright let's talk about the static keyword!

Variables and methods that have static in their introduction belong to the class instead of a specific instance.

0class MyApp {
 public static void main 
 (String[] args) {
  int myNumber = triple(2);
  System.out.print(myNumber);
 }
 static int triple(int number) {
  return number * 3;
 }
}

//Output Below

6

Good stuff! Because triple() is a static method, we can use it without creating an instance of MyApp.

Psst: did you notice that we never created an instance of System before we used the print() method? Well, that's because print() is also static.

The alternative

So, what if triple() wasn't a static method?

class MyApp {
 public static void main 
 (String[] args) {
  MyApp a;
  a = new MyApp();
  int myNumber = a.triple(2);
  System.out.print(myNumber);
 }
 int triple(int number) {
  return number * 3;
 }
}

See that? We'd need an instance of the MyApp class in order to use triple(). That'd be very inconvenient as it never uses any variables of the a instance.

Utility methods

In case it makes sense to call a variable or method even if we didn't create an instance of its class, it's smart to make it static.

class MyApp {
 public static void main 
 (String[] args) {
  double mpg = 26.9;
  double kpl = Car.convert(mpg);
  System.out.print(kpl);
 }
}

//Output Below

11.4363657183

class Car {
 // Convert MPG to KM per Liter:
 static double convert(double m) {
  return m * 0.425143707; 
 }
}

That's especially true for utility methods, which don't need instance variables or methods.

Private

Psst: some variables and methods don't want to be disturbed. How about we give them some privacy?

class Playground {
 public static void main 
 (String[] args) {
  Dog myDog = new Dog("Baxter");
  myDog.eat();
 }
}

class Dog {
 private int hunger = 10;
 void eat() {
  if (hunger > 0) {
   hunger--;
  }
 }
}

Perfect! By adding the private keyword to hunger, we're shielding it from being accessed from outside of its scope, the Dog class.

Publicity

In other cases, we might want a variable or method to be accessible from any other class.

class Dog {
 public String name;
 private int hunger = 10;
 void eat() {
  if (hunger > 0) {
   hunger--;
  }
 }
}

Sweet! By adding public before the declaration, any other class in the project can access name.

Psst: public and private are so-called modifiers. If we skip them, variables and methods are package-private, which is somewhere in between.

Space adventure #12

Traveling the "Wej" system, "Sam" has a secret message to transmit to her friend "Jar". Unfortunately, the system's government is very nosy.

Create a class with the secret message and include a method that takes a reader parameter and returns the message for nobody else but "Jar".

class Message {
 private String message;
 public String readMessage
 (String reader) {
  if (reader.equals("Jar")) {
   System.out.print("Access granted");
   return message;
  } else {
   System.out.print("Access denied");
  }
 }
}

That way, nobody except "Jar" can read the message.

Compendium

In Java, everything needs to be in a class and every program needs a class with a main()method.

class MyGame {
 public static void main
 (String[] args) {
  Hero myHero = new Hero("Thrall");
  myHero.levelUp();
 }
}

class Hero {
 public String name;
 private int level;
 public Hero() {
  this.name = name;
  this.level = 1;
 }
 public void levelUp() {
  if (level < 100) {
   level++;
  }
 }
}

Also, we can restrict access to variables and methods with modifiers.

javac anyName.java

java anyName.java