%cabeçalho para todos os capítulos
%\input{cabecalho}

%\begin{document}

%Opções para o pacote listings
%\input{listingOptions}

\chapter{\texttt{for}, leitura do teclado e conversão de Strings}

\begin{center}
\shabox{
  \begin{Bitemize}
    \item[]\textbf{Quais novidades veremos nesta aula?}
    \item \texttt{for} (mais um comando de repetição)
    \item Leitura de dados do teclado (classe SavitchIn)
    \item Conversão de Strings para números
  \end{Bitemize}
} % \shabox
\end{center}
\bigskip

\section{O comando \texttt{for}}

Você deve ter notado que quando implementamos laços com o comando while,
é muito comum que sigamos um padrão bem definido. Considere os dois
exemplos a seguir que vimos na aula passada:


\begin{lstlisting}
void listaDiasDaSemana ()
{
  int i = 0;
  while (i < 7)
  {
    System.out.println (diasDaSemana[i]);
    i++;
  }
}

void calculaQuadrados ()
{
  int i = 0;
  while (i < quadrados.length)
  {
    quadrados[i] = i*i;
    i++;
  }
}
\end{lstlisting}

Em ambos os casos, a estrutura do laço é a seguinte:

\begin{lstlisting}
int i = 0; // define onde o laço se inicia

// define o critério para continuarmos dentro do laço
while (i < quadrados.length)
{
  quadrados[i] = i*i; //a operação propriamente dita
  i++;  //comando de atualização para passarmos para a próxima iteração
}
\end{lstlisting}


Ou seja, um formato genérico para laços com \texttt{while} seria o seguinte:

\begin{lstlisting}
inicialização;
while (condição para continuar)
{
  comando;
  atualização;
}
\end{lstlisting}

Após muito observar este padrão, projetistas de linguagens de
programação decidiram criar um novo comando para implementação de laços
onde todas estas partes relacionadas ao laço fossem organizadas de uma
forma melhor. Assim, surgiu o comando for que, nas linguagens C, C++ e
Java, adquirem o seguinte formato:


\begin{lstlisting}
for (inicialização; condição para continuar; atualização )
{
  comando;
}
\end{lstlisting}

onde as chaves são apenas necessárias se comando for composto. Com o
\texttt{for}, podemos implementar exatamente o mesmo que com o \texttt{while} mas, no caso
do \texttt{for}, todas as operações relacionadas ao laço ficam na mesma linha o
que facilita a visualização e o entendimento de quem olha para o código.

\section{Leitura do Teclado}

Na aula passada, aprendemos como escrever um programa em Java que pode
ser executado a partir da linha de comando, sem a necessidade de
utilizar um ambiente como o DrJava para executá-lo. Aprendemos também a
receber dados como parâmetro através da linha de comando utilizando o
parâmetro \texttt{args} do método \texttt{main}. No entanto, existem casos em que
gostaríamos de ler valores digitados pelo usuário através do teclado
durante a execução do programa. Java oferece algumas formas de se fazer
isso mas nenhuma delas é muito simples. Para facilitar a vida de
iniciantes em programação Java, podemos utilizar uma classe que esconde
as partes mais complicadas da leitura através do teclado. Neste livro
utilizaremos a classe SavitchIn escrita pelo Prof. Walter Savitch da
Universidade da California em San Diego.

Em seus EPs e exercícios, para usar a classe SavitchIn, você pode
baixá-la do sítio do Prof. Savitch
\footnote{http://www.cs.ucsd.edu/users/savitch/java/SavitchIn.txt}.

Após compilar o SavitchIn.java para produzir o SavitchIn.class, basta
copiá-lo para o mesmo diretório onde os seus arquivos .class serão
guardados para que você possa utilizar os métodos da classe SacitchIn.
Uma descrição detalhada de todos os métodos da SavitchIn está disponível
na Web\footnote{http://www.sinc.sunysb.edu/Stu/fmquresh/SavitchIn.html}.
Mas, em MAC 110, nós vamos nos concentrar apenas nos seguintes métodos:

\begin{lstlisting}
public class SavitchIn
{
    public static String readLine();
    public static int readLineInt(); // supõe que há apenas um inteiro
na linha
    public static double readLineDouble(); // apenas um double na linha
    /************************************************************ **
     * In the following method
     * If the input word is "true" or "t", then true is returned.
     * If the input word is "false" or "f", then false is returned.
     * Uppercase and lowercase letters are considered equal. If the
     * user enters anything else (e.g., multiple words or different
     * words), then the user is asked to reenter the input.
     **************************************************************/
    public static boolean readLineBoolean();
}
\end{lstlisting}

A palavra \texttt{static} na declaração de cada método indica que este método
pode ser utilizado mesmo que não existam instâncias da classe. Para
utilizá-lo basta fazer algo como no exemplo seguinte:

\begin{lstlisting}
for (i = 1; i <= 10; i++)
{
    int num = SavitchIn.readLineInt();
    System.out.println (i + "o número digitado: " + num);
}
\end{lstlisting}

Nota: Por uma limitação do DrJava, a classe SavitchIn ainda não funciona
na janela Interactions. Segundo os desenvolvedores do DrJava, esta
limitação será solucionada no futuro. Portanto, por enquanto, você deve
utilizar a SavitchIn em programas a serem executados na linha de comando.

\section{Conversão de String para números}

Você deve ter notado que o método main recebe sempre Strings como
parâmetro. Mas e se quisermos receber valores numéricos? Neste caso
temos que converter o String que recebemos em um número. Isso pode ser
feito através da classe Integer ou da classe Double que contém métodos
para efetuar estas conversões:

\begin{lstlisting}
String meuStringInteiro = "10";
int meuInteiro = Integer.parseInt(meuStringInteiro);

String meuStringReal = "3.14159265";
double meuReal = Double.parseDouble(meuStringReal);
\end{lstlisting}

\section{Exercícios}

\begin{enumerate}
\item Usando o comando \texttt{for}, escreva um método que recebe um \emph{array} de
  \texttt{double}s como parâmetro e imprime o seu conteúdo.
  
\item Usando o comando \texttt{for}, escreva um método \texttt{somaArrays} que
  recebe 3 \emph{arrays} de mesmo comprimento como parâmetro e que calcula a
  soma dos dois primeiros e a armazena no terceiro. A soma deve ser
  implementada como soma vetorial, ou seja, soma-se a primeira posição de um
  vetor com a primeira posição do segundo, armazenando-se o resultado na
  primeira posição do terceiro e assim por diante. \emph{Nota: o terceiro
    \emph{array} que é passado como parâmetro é chamado de \textbf{parâmetro
      de saída}.  Quando o método se inicia, ele já contém um \emph{array} que
    é passado por quem chamou o método \texttt{somaArrays}, mas o seu conteúdo
    inicial não é relevante. O método preenche esse \emph{array} com valores e
    estes valores estarão disponíveis, após o retorno do método, para quem o
    chamou. Isso funciona em Java apenas quando passamos objetos como
    parâmetro (e \emph{array} é um objeto). Quando passamos tipos básicos, como
    \texttt{int}, isso não funciona, ou seja, o valor modificado pelo método
    não é visível a quem o chamou.}

\item Escreva um método que recebe um array de \texttt{doubles} como parâmetro e
  imprime a média dos valores nele contidos.

\item Escreva dois métodos (\texttt{min} e \texttt{max}) que recebem um array
  de inteiros como parâmetro e devolvem, respectivamente, um inteiro
  correspondente ao menor e ao maior elemento do array.

\item Escreva uma classe ProdutoEscalar contendo os seguintes métodos:
  \begin{enumerate}
  \item método que recebe um array "vazio" como parâmetro e que lê
    valores double do teclado para serem inseridos no array.
  \item método que recebe 2 arrays de double como parâmetro e
    devolve o produto vetorial (soma dos produtos das posições
    de mesmo índice dos dois arrays).
  \item método \texttt{main} que, usando os métodos anteriores, lê do teclado
    o comprimento dos vetores, lê do teclado o conteúdo de dois
    vetores com o tamanho comprimento, calcula o produto
    vetorial e imprime o resultado.
  \end{enumerate}
\end{enumerate}

%\end{document}
