Chamar programa externo [RESOLVIDO]

//Classe que executa o processo

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class ThreadProcesso extends Thread {
	private ProcessBuilder processBuilder;
	private ObservadorProcesso observador;
	
	public ThreadProcesso(ObservadorProcesso observador, File diretorio, String ...comandos){
		this.observador = observador;
		
		List<String> ListaDeComandos = new ArrayList<String>(2);

		for (String comando: comandos)
			ListaDeComandos.add(comando);
		
		processBuilder = new ProcessBuilder();
		processBuilder.command(ListaDeComandos);
		processBuilder.directory(diretorio);
	}
	
	@Override
	public void run(){
		Process processo;
		try {
			processo = processBuilder.start();
		} catch (IOException exception) {
			observador.execaoAoExecutarProcesso(exception);
			return;
		}
		
		try {
			processo.waitFor();
			observador.processoConcluido(processo);
		} catch (InterruptedException exception) {
			observador.monitoracaoInterronpida(processo, exception);
		}
	}
}

//Interface para implementação do padrão observer
package dominio;

import java.io.IOException;

public interface ObservadorProcesso {
	public void processoConcluido(Process processo);
	public void execaoAoExecutarProcesso(IOException exception);
	public void monitoracaoInterronpida(Process processo, InterruptedException exception);
}

/**
 * Classe observadora dos processos, notar que os métodos implementado de ObservadorProcesso
 * tem a palavra chave synchronized
 */

package dominio;

import java.io.IOException;

public class Teste implements ObservadorProcesso {

	public static void main(String[] args) {
		Teste testeProcessos = new Teste();
		
		ThreadProcesso threadProcesso = (new ThreadProcesso(testeProcessos, null, "notepad.exe"));
		threadProcesso.start();
		
		(new ThreadProcesso(testeProcessos, null, "calc.exe")).start();
		
		threadProcesso.interrupt();
		
	}

	@Override
	public synchronized void processoConcluido(Process processo) {
		System.out.println(String.format("Processo concluido: %s", processo.toString()));
	}

	@Override
	public synchronized void execaoAoExecutarProcesso(IOException exception) {
		exception.printStackTrace();
	}

	@Override
	public synchronized void monitoracaoInterronpida(Process processo,
			InterruptedException exception) {
		System.out.println(String.format("Monitoração do processo iterrompida: %s", processo.toString()));
		exception.printStackTrace();
	}
}