Essentials, Part 1, Lesson 2: Building Applications

The public static void keywords mean the Java ¹ virtual machine (JVM) interpreter can call the program's main method to start the program (public) without creating an instance of the class (static), and the program does not return data to the Java VM interpreter (void) when it ends.

An instance of a class is an executable copy of the class While the class describes the data and behavior, you need a class instance to acquire and work on data. The diagram at the left shows three instances of the ExampleProgram class by the names: FirstInstance, SecondInstance and ThirdInstance.

The main method is static to give the Java VM interpreter a way to start the class without creating an instance of the control class first. Instances of the control class are created in the main method after the program starts.

The main method for the simple example does not create an instance of the ExampleProgram class because none is needed. The ExampleProgram class has no other methods or fields, so no class instance is needed to access them from the main method. The Java platform lets you execute a class without creating an instance of that class as long as its static methods do not call any non-static methods or fields.

The ExampleProgram class just calls System.out.println. The java.lang.System class, among other things, has a static out field of type PrintStream that is used to invoke the print(ln) methods in the PrintStream class.

The static fields and methods of a class can be called by another program without creating an instance of the class. So, just as the Java VM interpreter command could call the static main method in the ExampleProgram class without creating an instance of the ExampleProgram class, the ExampleProgram class can call the static println method in the System class, without creating an instance of the System class.

However, a program must create an instance of a class to access its non-static fields and methods. Accessing static and non-static fields and methods is discussed further with several examples in the next section.

Fields and Methods

The LessonTwoA.java program alters the simple example to store the text string in a static field called text. The text field is static so its data can be accessed directly by the static call to out.println without creating an instance of the LessonTwoA class.

class LessonTwoA {
   static String text = "I'm a Simple Program";
   public static void main(String[] args){
        System.out.println(text);
   }
}

class LessonTwoB {

   String text = "I'm a Simple Program";
   static String text2 = "I'm static text";

   String getText(){
        return text;
   }

   String getStaticText(){
        return text2; 
   }

   public static void main(String[] args){
        LessonTwoB progInstance = new LessonTwoB();
        String retrievedText = progInstance.getText();
        String retrievedStaticText = 
                 progInstance.getStaticText(); 
        System.out.println(retrievedText);
        System.out.println(retrievedStaticText);
   }
}

class LessonTwoC {

   static String text = "I'm a Simple Program";

//Accessor method
   static String getText(){
        return text;
   }

   public static void main(String[] args){
        String retrievedText = getText();
        System.out.println(retrievedText);
   }
}

class LessonTwoD {

   String text;

//Constructor
   LessonTwoD(){
     text = "I'm a Simple Program";
   }

//Accessor method
   String getText(){
        return text;
   }

   public static void main(String[] args){
        LessonTwoD progInst = new LessonTwoD();
        String retrievedText = progInst.getText();
        System.out.println(retrievedText);
   }
}