Preciso de ajuda urgente!

//sempre q tiver // no código indica que é um comentário...

/** 
 * também são comentários este tipo de trecho,
 * geralmente usado para documentar a classe.
 *
 * bom aqui eu estou criando um objeto HelloWorld q é publico
 * , ou seja, qualquer objeto poderá usa-lo.
 */
public class HelloWorld {

   /** 
	*   bom aqui eu defino um field, em outras linguagens 
	*   é comumente chamado de variável
	*   este objeto é de propriedade do objeto HelloWorld e é privado,
	*   sendo assim ninguem poderá acessa-lo, só o próprio HelloWorld.
	*/
   private String msg = null;
   
   /**
    * Método getMessage, que aqui é usado para retornar a mensagem
    * que está gravada dentro do field privado msg. ele retorna de
    * forma segura o valor da mensagem, verificando se este ainda 
    * está nulo, se estiver, muda seu valor para "Hello World!"
    * e então o retorna
    * 
    * @return retorna a message do HelloWorld
    */
   public String getMessage() {
   	  //Nome que este if não tem {} isso ocorre pq ele só tem um 
   	  //argumento dentro, não precisando assim abrir e fechar as
   	  //chaves.
   	  //nestes casos, muitas vezes se escreve assim:
   	  //if (msg == null) setMessage();
   	  //em 1 linha só.
   	  //este método verifica se o valor da msg ainda está nulo, 
   	  //sendo isso verdade ele chama o método setMessage() para
   	  //dar valor a msg, isto é feito por segurança, para não
   	  //passar um valor nulo.
      if (msg == null)
	     setMessage();
      
      //aqui ele irá retornar o valor contigo em msg que pertence
      //a este objeto. o operador this, indica que está se tratando
      //de um field q é do objeto e não do método, veremos isso 
      //no método setMessage(String msg) 
      return this.msg;
   }
   
   /**
    * Seta a mensagem passada através de msg, como sendo a messagem
    * deste objeto. No caso de msg estar nulo, xamará o método
    * setMessage().
    * @param msg mensagem a ser gravada pelo objeto.
    */
   public void setMessage(String msg) {
   	  //note aqui que o teste if msg == null é feito para a o 
   	  //field do método setMessage(String msg) e não para aquele
   	  //do objeto, definido lá em cima com: 
   	  //private String msg = null;
   	  //quando há 2 nomes de fields iguais, ele irá usar o field
   	  //do método, para chamar o field do objeto vc terá que usar
   	  //o operador this.
   	  //Então aqui eu testo se msg é null é se for, eu uso o método
   	  //setMessage() ou seja, se o cara passar msg = null, é o mesmo
   	  //de ter chamado o método setMessage(), sendo assim, esse dois
   	  //métodos seguintes tem o mesmo efeito:
   	  //setMessage(), setMessage(null)
   	  if (msg == null) {
   	     setMessage();
   	  //no caso de msg não estar nulo, o objeto irá guardalo em 
   	  //seu field privado, usando para isto o operador this.msg
   	  //para falar a classe q se trata do field exteno, sendo igual
   	  //ao field passado neste método.
   	  } else {
	     this.msg = msg;
   	  }
   }
   
   /**
    * método que seta o valor da msg como Hello World, pos
    * nenhum argumento foi passado para escolher que mensagem 
    * passar
    */
   public void setMessage(){
      //define msg do objeto
   	  this.msg = "Hello World!";
   }
   
   /**
    * cria um objeto hello world com a mensagem padrão definida
    * em setMessage().
    */
   public HelloWorld() {
      setMessage();
   }
   
   /**
    * cria um objeto hello world com a mensagem passada através
    * de msg
    * @param msg mensagem a ser gravada no objeto.
    */
   public HelloWorld(String msg) {
   	  setMessage(msg);
   }
   
   /*
    * Estes 2 últimos comandos são construtores da classe, ou 
    * seja, as manerais de criar um objeto HelloWorld, no outro
    * objeto Main, nós usaremos 2 objeto HelloWorld, para
    * exemplificar
    */
}

/**
 * está classe ira funcionar como um programa
 * do tipo console, que irá ter saida de textos
 * para rodalo use o comando
 * java Main
 * 
 * etando está classe e a classe HelloWorld dentro da pasta
 * da makina virtual java, existe outras maneiras de rodar
 * este programa...
 */
public class Main {
   //para uma classe ser utilizada como um programa
   //ela deverá ter um método: 
   //public static void main(String[] args)
   //ou seja, um método main publico q é estatico,
   //e pode ser xamado com uma array de strings.
   // método statico, é aquele que pode ser executado
   //sem q vc crie o objeto, você ode xamalo através
   //do nome da classe, exemplo: MinhaClasse.metodoStatico();
   
   /**
    * esté é o método que xama o plicativo, ou seja, se você
    * deseja criar um programa é por aqui q vc deve comessar.
    * 
    * ele é definido como void, pq o método não tem nenhum
    * retorno, como publico pois qualquer um deve conseguir 
    * rodar o programa, e como statico pq não deve ser 
    * necessário criar uma classe para xamar o programa.
    * 
    * o String[] args é para vc poder passar argumentos para
    * o programa, um xemplo de programa q usa isso é o format
    * format C: /s 
    * neste comando vc chama o programa format, e passa a ele
    * os argumentos "C:" , "/s", da mesma forma funciona para
    * java, voccê pode passa argumentos para o método main,
    * que roda o programa. o 1º argumento ficará em args[0]
    * e assim por diante.
    */
   public static void main(String[] args) {
   	  //cria um objeto que fará o comprimento em englês
   	  //lembrando lá da classe HelloWorld, quando nenhuma
   	  //msg é passada, ele cria um objeto com a messagem
   	  //Hello World, ou seja, para um HelloWorld englês é
   	  //só manter a original.
   	  HelloWorld comprimentadorEngles = new HelloWorld();
   	  
   	  //cria um objeto que guarda a messagem "Olá mundo!".
   	  //Pois o construtor HelloWorld("Olá Mundo!") irá 
   	  //chamar o método setMessage("Olá Mundo!").
   	  HelloWorld comprimentadorBrasileiro = new HelloWorld("Olá Mundo!");
   	  
   	  //arqui eu crio uma string com a mensagem orla mundi.
   	  String latim = "Orla Mundi!";
   	  //Outra maneira de criar um objeto HelloWorld.
   	  HelloWorld comprimentadorLatino = new HelloWorld(latim);
   	  
   	  //bom agora vamos imprimir as mensagens para ver o
   	  //resultado.
   	  //Usando o método System.out.println(Strign msg);  
   	  //que imprime uma mensagem na saida padrão.
   	  
   	  //Imprime a mensagem de comprimento do Englês.
   	  System.out.println(comprimentadorEngles.getMessage());
   	  
      //Imprime a mensagem de comprimento do Brasileiro.
      System.out.println(comprimentadorBrasileiro.getMessage());
      
      //Imprime a mensagem de comprimento do Latino.
      System.out.println(comprimentadorLatino.getMessage());
   }
   
   //espero que vc tenha entendido... =]
}