\chapter{Utilizando o Dr. Java}

\section{Introdução}

\texttt{DrJava} é um ambiente de desenvolvimento para a linguagem \texttt{Java}. Por
ser ele mesmo escrito em \texttt{Java}, pode ser usado em diversos ambientes,
como, por exemplo, \texttt{Linux}, \texttt{Windows} e \texttt{Mac OS}. Um ambiente de
desenvolvimento (também conhecido por IDE, de \emph{Integrated Development
Environment}) é um conjunto de ferramentas integradas que auxiliam a
construção de programas.

O \texttt{DrJava} se encontra em desenvolvimento, por isso alguns recursos
desejáveis ainda não estão disponíveis. Entretanto, os recursos mais
simples que ele fornece já são apropriados para os nossos objetivos
nesta disciplina. Planejamos então utilizar o \texttt{DrJava} para escrevermos
nossos programas \texttt{Java} deste semestre.


\subsection*{Objetivos}

Esperamos com esta aula introduzir o uso do \texttt{DrJava}. O conteúdo da aula
é limitado e específico, suficiente para que você posteriormente seja
capaz de conhecer melhor esta ferramenta por conta própria. Recomendamos
para isso a consulta de manuais e outros documentos, não necessariamente
sobre \texttt{DrJava} apenas. As descobertas pelo próprio uso e através de
dicas de colegas também são incentivadas.

Nesta aula você aprenderá a utilizar o \texttt{DrJava} para

\begin{itemize}
  \item escrever, compilar, manipular e depurar classes/objetos simples;
  \item gravar e reutilizar os arquivos que descrevem seus objetos.
\end{itemize}

Questões mais gerais sobre uso do computador, como impressão do código
fonte e manipulação de arquivos fora do \texttt{DrJava}, dependem muito do
ambiente que você utiliza e por isso não são abordados nesta aula. No
IME estão à disposição dos alunos dois laboratórios que possuem
ambientes bem distintos: as salas Pró-Aluno
<http://www.linux.ime.usp.br> e o CEC. Sugerimos que você consulte os
documentos de ajuda disponibilizados pela própria administração de cada
laboratório para resolver esse tipo de dúvida.

\subsection{Como obter, instalar e executar o \texttt{DrJava}}

Essas informações estarão disponíveis no sítio da disciplina.


\section{Conversor de Temperatura simples}

Como exemplo inicial, vamos construir a classe \texttt{Conversor} vista em
aula. Lembrando, cada objeto dessa classe converte apenas a temperatura
de 40 graus celsius para a correspondente em graus fahrenheit. Para
isso, ao receber a mensagem \texttt{celsiusParaFahrenheit}, ele devolve a
temperatura em fahrenheit equivalente a 40 graus celsius.


\subsection*{Editando o código-fonte num arquivo}

Vejamos o que o \texttt{DrJava} nos oferece para criarmos a classe. Ao iniciar
o ambiente \texttt{DrJava}, abre-se uma janela parecida com a seguinte.

%\bigskip
\begin{figure}[ht]
\begin{center}
\includegraphics[%
  clip,
  width=10cm,
  angle=0]{images/drjava/ss-def.png}
\end{center}
\end{figure}

O painel de definições, indicado na figura acima, é um editor de textos.
É nele que digitaremos o código \texttt{Java} que define a classe \texttt{Conversor}.
Ele se parece muito com um editor de textos comum, exceto que possui
alguns recursos para facilitar a digitação de código. Em particular, o
comportamento das teclas <Enter> e <Tab> favorece a indentação do
código. Outro recurso útil é a coloração e destaque do texto.

Precisamos criar um arquivo novo para conter o código da nossa classe.
Para isso, bastaria escolher a opção \textbf{New} do menu \textbf{File}. Porém, quando
abrimos o \texttt{DrJava}, um novo arquivo sem nome já foi criado, então
podemos usá-lo nesse momento (em vez de criar um novo). Sendo assim,
digite o seguinte código no painel de definições.

\begin{lstlisting}
class Conversor 
{
  int celsiusParaFahrenheit () 
  {
    return 9 * 40 / 5 + 32;
  } 
}
\end{lstlisting}

Ao digitar, note os recursos mencionados que ajudam a programação
(principalmente o comportamento das teclas <Enter> e <Tab>).


\subsection*{Gravando e reutilizando o arquivo}

Vamos agora gravar o arquivo no disco. Escolha o menu \textbf{File} (clicando
com o \emph{mouse} ou usando as teclas de atalho, que nesse caso é a
combinação <Alt>+<F>) e escolha o item \textbf{Save}. Como o arquivo ainda não
tem nome, estaremos na verdade acionando a opção \textbf{Save as...}. Por isso,
surgirá um \emph{diálogo} para definirmos a localização e o nome do arquivo,
como mostra a seguinte figura.

%\bigskip
\begin{figure}[ht]
\begin{center}
\includegraphics[%
  clip,
  width=6cm,
  angle=0]{images/drjava/ss-jan_saveas.png}
\end{center}
\end{figure}

Podemos determinar a localização manipulando a \emph{combo box} com rótulo
\textbf{Save In:} (no topo do diálogo) e escolhendo um diretório na caixa
abaixo dela.

Ou podemos deixar a localização como está. Desse modo, provavelmente o
arquivo será gravado no diretório de onde o \texttt{DrJava} foi chamado.

Também precisamos escolher o nome do arquivo. Em algumas ocasiões, este
deve ser \emph{obrigatoriamente} idêntico ao nome da classe, mais o sufixo
.java. Não é o nosso caso, mas mesmo assim vamos chamar o arquivo de
Conversor.java. Como já digitamos o código da classe, o \texttt{DrJava}
preencheu o nome do arquivo no \emph{input field} de rótulo \textbf{File Name:} com
o nome da classe. Note também que ele não acrescentou o sufixo .java no
nome, isso será feito implicitamente quando finalizarmos (mas não há
problema em digitar o sufixo mesmo assim).

Para confirmar a gravação, basta clicar no botão \textbf{Save}. As modificações
futuras podem ser gravadas com o comando \textbf{Save}, sem precisar escolher o
nome do arquivo novamente.

Com os arquivos das classes gravados em disco, podemos querer
reutilizá-los no futuro. No \texttt{DrJava}, basta escolhermos a opção \textbf{Open}
do menu \textbf{File}, e um diálogo permitirá que você escolha o arquivo que
deseja abrir novamente (é semelhante ao processo do \textbf{Save as...}).


\subsection*{Compilando a classe}

Acabamos de definir a nossa classe, precisamos agora compilar para que
possamos usá-la. No menu \textbf{Tools}, temos duas opções para fazer isso,
\textbf{Compile All Documents} e \textbf{Compile Current Document}. Como só temos um
documento aberto (Conversor.java), qualquer uma das opções serve.
Escolha então \textbf{Compile Current Document}.

Com isso compilaremos a nossa classe. Note que no painel inferior da
janela, a \emph{guia} \textbf{Compiler Output} se abre mostrando algumas mensagens.
Se tudo der certo, a nossa janela se parecerá com a seguinte.

%\bigskip
\begin{figure}[ht]
\begin{center}
\includegraphics[%
  clip,
  width=10cm,
  angle=0]{images/drjava/ss-comp.png}
\end{center}
\end{figure}

\subsection*{Usando a classe}

Podemos finalmente usar a guia \textbf{Interactions}, que chamaremos de \emph{janela
do interpretador}, para criar e usar objetos da classe \texttt{Conversor}. Essa
janela recebe comandos num \emph{prompt}, e a sintaxe desses comandos é muito
parecida com a da linguagem \texttt{Java}.

Clique então em \textbf{Interactions}, e digite o seguinte.

\begin{lstlisting}
Conversor conv = new Conversor();
conv.celsiusParaFahrenheit()
\end{lstlisting}

A ausência de \texttt{;} no final da linha do comando faz com que o
interpretador imprima o valor devolvido pelo comando.

A janela do interpretador deverá se parecer com a figura abaixo.

%\bigskip
\begin{figure}[ht]
\begin{center}
\includegraphics[%
  clip,
  width=10cm,
  angle=0]{images/drjava/ss-inter.png}
\end{center}
\end{figure}

\section{Tratando erros}

Utilizaremos agora a classe \texttt{Conversor4} vista em aula para mostrarmos
alguns outros recursos do \texttt{DrJava}. Para quem não lembra, objetos dessa
classe convertem temperaturas entre graus Celsius e Fahrenheit
fornecendo os seguintes métodos.

    * \texttt{double celsiusParaFahrenheit (double c)}: recebe uma temperatura
      \texttt{c} em graus celsius e devolve a temperatura correspondente em
      graus fahrenheit.
    * \texttt{double fahrenheitParaCelsius (double f)}: recebe uma temperatura
      \texttt{f} em graus fahrenheit e devolve a temperatura correspondente em
      graus celsius.

Para esta aula dirigida, porém, usaremos um código um pouco diferente em
relação ao dado em aula normal.


\subsection*{Erros no código}

Feche o arquivo Conversor.java usando a opção \textbf{Close} do menu \textbf{File} e
crie um novo arquivo (na verdade, como havia apenas um arquivo aberto,
um novo é criado automaticamente).

Digite nesse arquivo o código abaixo (há erros intencionais nele). Você
pode também usar o recurso de \emph{copiar} e \emph{colar} (\emph{copy and paste}).

\begin{lstlisting}
class Conversor4
{
  double celsiusParaFahrenheit (double c)
  {
    double f = 9.0 * c / 5.0 + 32.0
    return f;
  }
  double fahrenheitParaCelsius(double f)
  {
    double c = 9.0 * (f - 32.0) / 9,0;
    return c;
  }
}
\end{lstlisting}

Grave o arquivo e compile. Como o código contém erros, o compilador não
terá sucesso e imprimirá algumas mensagens. Algo como mostra a figura
abaixo.

%\bigskip
\begin{figure}[ht]
\begin{center}
\includegraphics[%
  clip,
  width=10cm,
  angle=0]{images/drjava/ss-comp_erros.png}
\end{center}
\end{figure}

O primeiro erro pode ser eliminado acrescentando-se um \texttt{;} no final da
linha 5. Veja que o próprio compilador sugere isso.

Já a descrição do segundo erro pode ser um pouco confusa. É importante
saber que o compilador é capaz de encontrar erros no código, mas nem
sempre pode determinar a causa exata. Nesses casos, as mensagens de erro
apenas dão pistas para descobrirmos o que está errado (algumas vezes
pistas falsas).

O segundo erro é uma vírgula no lugar de um ponto, no final da linha 10.

Há outros tipos de erro os quais o compilador não tem condições de
detectar. Um exemplo é o erro na fórmula de conversão da linha 10. Há um
\texttt{9.0} onde deveria estar um \texttt{5.0}.

Vimos em aula uma maneira de detectarmos tais erros através de testes.
Mas depois de detectarmos, precisamos descobrir a causa deles. Veremos a
seguir uma ferramenta útil para essa tarefa.

Mas antes corrija os erros e compile.


\subsection*{Depurador}

Depurador (\emph{debugger}) é uma ferramenta que nos ajuda a corrigir erros
(\emph{bugs}) de programas. O depurador do \texttt{DrJava} oferece apenas recursos
básicos: pontos de parada (\emph{breakpoints}), execução passo a passo
(\emph{step}) e inspeção simples de variáveis (\emph{watch}). Mesmo assim, a
classe \texttt{Conversor4} não é complexa o suficiente para justificar a
aplicação do depurador, vamos utilizá-la apenas para demonstrar
rapidamente cada um desses recursos.

Para ativar o depurador, escolha a opção \textbf{Debug Mode} do menu
\textbf{Debugger}. Ao fazer isso, o painel de depuração é exibido na janela
principal.

%\bigskip
\begin{figure}[ht]
\begin{center}
\includegraphics[%
  clip,
  width=10cm,
  angle=0]{images/drjava/ss-dep.png}
\end{center}
\end{figure}

Começaremos selecionando um ponto de parada no código do \texttt{Conversor4}.
Isso é feito no painel de definições, posicionando o cursor na linha
desejada e escolhendo a opção \textbf{Toggle Breakpoint on Current Line} do
menu \textbf{Debugger}.

O ponto de parada faz com que a execução do programa seja
temporariamente interrompida exatamente antes da linha ser executada. A
partir daí, para continuar a execução, deve-se usar os comandos de
"passo a passo" (\emph{step into}, \emph{step over}, \emph{step out}, \emph{resume}). O que
cada comando faz pode ser encontrado na seção \emph{Documentation} da página
do \texttt{DrJava} <http://drjava.sourceforge.net>

Posicione então o cursor do painel de definições na linha 10 do
\texttt{Conversor4}, e insira um ponto de parada (a linha ficará com um
destaque vermelho). Para que o ponto de parada seja usado, temos que
fazer com que o método seja executado. Para isso digite o seguinte na
janela do interpretador.

\begin{lstlisting}
Conversor4 c4 = new Conversor4();
c4.fahrenheitParaCelsius(42)
\end{lstlisting}

A execução do método será interrompida antes da linha 10 ser executada.
O destaque azul da linha indica isso. Para continuar a execução passo a
passo (linha a linha), execute o comando \emph{step over} algumas vezes
(pressionando a tecla <F11>).

Dessa forma, é possível constatar quais trechos de código são usados
numa execução em particular.

Um outro recurso bastante útil, que deve ser usado em conjunto com esses
que acabamos ver, é a inspeção de valores de variáveis (\emph{watch}).

Esse recurso nos informa o valor de certas variáveis durante a execução
passo a passo. Para isso, é necessário preencher a coluna \emph{Name} da
tabela da guia \emph{Watches} com os nomes das variáveis que se deseja
inspecionar (uma variável em cada linha da tabela). Basta clicar numa
célula da coluna \emph{Name}, digitar o nome da variável e pressionar <Enter>.

Então faça isso para as variáveis \texttt{c} e \texttt{f}. Teremos algo como a próxima
figura.

%\bigskip
\begin{figure}[ht]
\begin{center}
\includegraphics[%
  clip,
  width=5cm,
  angle=0]{images/drjava/ss-watch.png}
\end{center}
\end{figure}

Repita a execução passo a passo descrita anteriormente e observe o que
ocorre com a tabela.

Dica: o interpretador armazena os últimos comandos digitados na janela.
Para acessá-los, pressione as setas para cima e para baixo do teclado.
Esse recurso se chama \emph{History}, e possui algumas opções úteis no menu
\textbf{Tools}.


% \chapter{Sobre o Dr. Java}

% DrJava é o nome de uma IDE Java bem simples. Ele permite a edição de múltiplas classes (arquivos), com direito a indentação automática e "coloração" do código. Para compilar tudo basta apertar um botão. Erros de compilação são destacados no código para serem corrigidos. Tudo é bem simples e direto, uma grande vantagem. Por fim também é possível depurar um programa no DrJava. O depurador é bem simples, permite apenas rodar o programa passo-a-passo, criar "pontos de parada" e inspecionar os valores de variáveis. Mais uma vez acho que a simplicidade é uma vantagem.

% Outra característica interessante do DrJava é a presença do painel iterativo. É como um "shell" que permite instanciar e manipular objetos. Isso facilitar a exploração da linguagem pelos alunos, uma vez que aquilo que ele pede que seja feito acontece instantaneamente. Acredito também que o painel pode ser útil durante alguma aula. Um efeito colateral do painel iterativo é que é possível evitar a função "main" por algum tempo. Para usar um objeto basta instanciá-lo no painel e usá-lo. O "main" pode ser apresentado depois apenas para automatizar testes ou iniciar a computação.

% Infelizmente o programa também tem suas desvantagens:

% \begin{enumerate}
% \item A última versão estável está com um pau. Estou com uma versão beta, que consegui com o desenvolvedor, que funciona.
% \item Um programa java disparado do painel iterativo não tem acesso à entrada padrão. Isso deve mudar no futuro (está na lista de tarefas do desenvolvedor), mas provavelmente vamos ter que viver com isso esse semestre. Acho que a idéia do testador do Alfredo faz com que esse problema seja menor.
% \end{enumerate}

% De qualquer forma achei o DrJava a opção mais interessante que temos. O BlueJ também é bom, mas eu realmente não gosto muito da idéia de usar UML no início.


