Auxílio Java: 2010

Entrada básica de dados

Para que os programas possam ficar mais interessantes, é extremamente crucial que eles interajam com o usuário. Uma das maneiras que podemos fazer isso, é utilizando a entrada de dados.
Existem várias maneiras de entradas de dados. De começo, iremos aprender a mais simples e fácil de todas. Utilizaremos a classe Scanner pra realizar a leitura do teclado.
Antes de tudo, é necessário importar a classe Scanner. Se você estiver utilizando uma IDE, isso será automático, mas caso esteja no bloco de notas, deverá importar no início da classe. Em seguida, dentro do método é só criar um novo objeto Scanner. Veja o exemplo:

Feito isso, para toda entrada de dados via teclado usaremos nosso objeto "in" para chamar os métodos da classe Scanner. Existem vários, mais os principais são:

next(): retorna uma string inserida no teclado até o primeiro espaço encontrado.
nextLine(): retorna uma string contendo uma linha inteira inserida pelo teclado(lê tudo até encontrar a tecla "Enter").
nextInt(): retorna o próximo inteiro digitado pelo teclado.

Existe vários outros, mas esses são os principais.
Se quisermos ler um inteiro do teclado, a sintaxe seria a seguinte:

<variável inteira> = <nome o objeto>.nextInt();

Veja um exemplo de um programinha com entrada de dados:

Exercício Proposto

Faça um programinha que terá que montar o cabeçalho da data atual. Terá de ter

Duas variáveis inteiras, que armazenarão o dia e o ano.
Duas strings, que armazenarão sua cidade e o mês.

A saída de dados devera ficar assim:

Qualquer Dúvida, é só comentar.

Anterior << Declaração de Variáveis
Próximo >>Tomadas de Decisão

Laços de Repetição

Na linguagem Java, possuímos três blocos de repetição. Na verdade, possuímos mais um recurso, que é a recursividade, mas que já passa a ser uma estrutura de algoritmo do que uma estrutura da linguagem.

Os três comandos são: while, do/while e for.

while(enquanto)

O comando while verifica uma condição lógica primeiro e depois executa as ações que estão contidas em seu bloco. sua sintaxe é a seguinte:

                                                 while(<condição lógica>){
                                                            ...comandos...
                                                 }

Sendo assim, tudo vai ser repetido até a condição se tornar falsa. No while não está garantido que seus comandos serão executados pelo menos uma vez porque antes da execução existe uma condição que verifica se o bloco pode ser executado.
A utilização do while se torna mais atraente quando precisamos repetir algo que não seja fixo, algo irregular. Por exemplo, um comando que controla um menu de usuário, onde não sabemos quando o usuário vai fechar o menu.

Veja mais no vídeo:

do/while(repita)

O comando do/while executa primeiro o bloco e depois verifica a condição lógica. A sintaxe é a seguinte:

                                                 do{
                                                            ...comandos...
                                                 }while(<condição lógica>);

Todo o bloco se repetirá até a condição se tornar falsa. No do/while, pelo menos uma vez o bloco será executado. Ele executará todo o bloco e depois verificará a condição, diferente do while, que verificava antes de executar.
Assista ao vídeo:

for(para)

O comando for é uma estrutura onde possui todo o controle na sua assinatura. Nela podemos declarar variáveis, verificar condições e incrementar valores à variável de controle. A sintaxe é a seguinte:

          for (<declara variável>; <condição de controle>; <incrementa a variável>){
                                                            ...comandos...
        }

A aplicação do comando for seria ideal quando possuímos um controle exato da repetição, como por exemplo, quando sabemos que iremos percorrer um vetor ou um número certo de repetições. Caso contrário, o ideal seria o while.

Veja mais no vídeo:

Exercício Proposto

Construa um programa que enquanto o usuário digitar um número diferente de zero(0), ele multiplique o número inserido por 1 até 10 e imprima o resultado na tela.
O resultado deverá ser semelhante a este:

Após fazer como este, aplique os conhecimentos de if/else para evitar que a tabuada do zero seja impressa na tela.

Qualquer dúvida, é só comentar.

Anterior << Tomadas de Decisão
Próxima >>

Tomadas de Decisão

As tomadas de decisão são extremamentes importantes na execução dos programas. São elas que dão a inteligência aos sistemas.

Em Java, temos dois blocos de tomadas de decisão: o IF/ELSE e o SWITCH/CASE.

IF/ELSE

O bloco IF/ELSE é o mais utilizado. Ele aceita qualquer condição e por isso é mais utilizado que o SWITCH. Sua sintaxe é a seguinte

if (<condição>) {

}

onde na condição colocaremos uma equação lógica ou um valor booleano(variável, método com retorno lógico). Se a condição for verdadeira, o que estiver dentro do bloco será executado.
Esse é um bloco simples, onde só se executa uma ação onde tal condição for verdadeira. Mas podemos forçar outra ação se a condição for falsa. Veja como:

if (<condição>) {

}else{

}

Nesse caso, o bloco else(se não) será executado quando a condição do if(se) for falsa. Podemos ainda alinhar mais blocos, permitindo mais condições a serem avaliadas. Veja o exemplo:

Podem ser utilizados quantos if/else for preciso.

Assista a esses vídeos sobre o comado if:

SWITCH/CASE

O comando SWITCH é um comando mais simples e organizado, porém muito limitado. Não podemos utilizar condições lógicas e apenas tipos primitivos são aceitos. Sua estrutura é a seguinte:

            Switch (<equação ou variável>){
            case <variável primitiva>:
               break;
            case <variável primitiva>:
                 break;
            }

Um exemplo seria esse:

Sempre é bom lembrar que não podemos utilizar condições lógicas nos cases, apenas tipos primitivos(inteiros, reais e caracteres isolados).

Veja mais nesse vídeo

Exercício Proposto

Implemente na classe AuxilioJava um bloco if/else ou switch/case que verifica se a soma de numeroA com numeroB é par ou ímpar.
Dica: O algoritmo poderá usar o operador %, que retorna o resto de uma divisão. Exemplo:

Dúvidas? Comentem

Anterior << Entrada básica de dados
Próximo >> Laços de Repetição

Estrutura Básica de um programa Java

Os programas em Java sempre são formados por blocos alinhados. Existem vários blocos dentro de blocos.

Os blocos são denotados por sua nomemclatura, inicio e fim. O inicio de um bloco é demarcado por "{" e para o fim é usado "}". Já a nomenclatura é diversificada, pois existem inúmeros tipos de blocos, como por exemplo, um bloco IF:

if (i != max) {
if (i == 1) {
frase += " " + i;
} else {
frase += ", " + i;
}
} else {
frase += " ou " + i + " = ";
}

O código acima possui vários blocos. O primeiro começa na linha 1("if (i != max)") , e termina na linha 7. Temos dois blocos em seu interior, e após ele, mais um. Todos com suas respectivas aberturas e fechamentos.

É extremamente necessário, após a abertura de um bloco, o fechamento do mesmo. Um bloco não fechado dará um erro no compilador Java.

Sendo assim, todo programa Java é formado por um bloco principal. Essse bloco chamamos de classe e é dentro dele que se desenrola o programa.

Na nomemclatura da classe, definimos seu nome e seu acesso. De inicio, não será necessário aprender os modificadores de acesso, então a estrutura padrão será sempre assim:

public class significa que será uma classe pública, onde poderá ser acessada por qualquer um. "AuxilioJava" é o seu nome, a sua identificação, por onde será chamada. Tudo que tiver dentro de seu bloco poderá ser executado sempre que for chamado AuxilioJava.

Para que as coisas possam funcionar, é preciso termos os empregados com suas funções. Em Java, chamamos isso de métodos. Todas as operações ocorrem dentro de métodos. Para isso, precisamos definir qual será o método onde tudo vai começar. A nomenclatura do método principal é a seguinte:

public static void main (String [] args){

}

Na hora da execução do programa, a JVM irá procurar por esse método para iniciar o programa. Por enquanto, basta saber que o programa começa por ai. Na aula sobre métodos, explicaremos melhor o significado de toda essa nomemclatura(daqui pra frente, assinatura de método).

Dentro dos métodos escrevemos os comandos. Os comandos são encerrados com ponto-e-vírgula(;) Um comando pode exceder uma linha, como também podemos ter mais de um comando em uma linha(desde que estejam separados pelo ponto ";"), porém é aconselhável usarmos uma linha pra cada comando.

Já que sabemos como é a estrutura básica de um programa em Java, iremos escrever um programinha que imprime uma mensagem na tela. Construa um programa igual ao mostrado abaixo e execute.

Pronto. Você acabou de criar um programa(embora inútil) na linguagem mais poderosa da Terra! Segue abaixo um vídeo do Chimura bem detalhado sobre o que aprendemos:

Próximo >> Tipos Primitivos

Declaração de Variáveis

Para podermos utilizar variáveis em Java, antes de tudo precisamos declará-las.

Isso é um processo bem simples, e que pode ser feito de várias maneiras.

As anotações em verdes são apenas comentários.

int numDificuldade;//DECLARANDO UM INTEIRO
int limiteInf = 0;//DECLARANDO UM INTEIRO E JÁ ADICIONANDO VALOR
char letra, letraNome = 'A', letraSobreNome = 65; //DECLARANDO VÁRIAS VARIÁVEIS NA MESMA LINHA
String nomeCompleto = nome + " " + sobrenome; //DECLARANDO UMA STRING COM O VALOR DE DUAS

Segue abaixo um print de uma declaração:

Embora existam inúmeras maneiras de declaração, as "Boas Práticas de Programação" orientam que seja declarada uma variável por linha. Isso facilita a leitura e análise do código.

Os nomes de variáveis em Java devem sempre começar com a primeira letra minúscula. É sempre importante colocamos nomes que identificam a sua função, por exemplo, nada mais justo nomear como "soma" a variável que for armazenar uma soma . Se tivermos duas somas, podemos então nomear desta maneira: somaAnterior e somaAtual. A regra é sempre tornar a primeira letra da próxima palavra maiúscula. Veja exemplos.

String nomeCompleto;
int diaNascimento;
char letraRespostaUsuario;

Sobre o nome de variáveis, clique aqui e saiba mais.

Como foi visto nos exemplos acima, para atribuirmos valores as variáveis, é utilizado o sinal "=". Tudo o que tiver depois do sinal de igual e entre o ponto-e-vírgula(;) será atribuído á variável.

Veja no vídeo:

Exercício Proposto

No primeiro programa que construimos , faça as seguintes alterações

Declare tres variáveis tipo int;
Uma variável do tipo String como o nome "resultado"
Atribua qualquer valor inteiro à duas variáveis tipo int
Some as duas variáveis e atribua esse valor a terceira variável inteira;
Atribua o seguinte valor á string: "Resultado da soma é: "
Imprima o resultado utilizando a string junto com a soma.

Deverá ficar mais ou menos assim ( o nome das variáveis podem ser diferentes):

Anterior << Tipos primitivos e operadores
Próximo >> Entrada básica de dados

Tipos Primitivos e Operadores

Tipos Primitivos

As variáveis em Java podem ser usadas para armazenar valores numéricos, lógicos e caracteres. Existem vários tipos, que são usados dependendo da aplicação e do valor à ser armazenado.

Tipos numéricos:

byte, short, long, int, double e float.

Lógico:

boolean

Caracter:

char

Os tipo mais utilizados são int, double , boolean e char. Com esses quatros tipos, podemos fazer tudo o que precisarmos. Porém, em alguns casos existem a necessidade do uso de outros, por exemplo, se precisarmos economizar memória. Nesse caso, podemos trocar double por float e int por short. Mas essas necessidades quase nunca acontecem, fazendo com que quase 100% dos programas usem esses 4 tipos.
Para a armazenagem de palavras e textos, o Java não possue tipo primitivo, mas a classe String. Em algumas linguagens, String é tratada como tipo primitivo.

Operadores

Os operadores em Java são:

Veja o vídeo sobre operadores matemáticos:

Veja agora sobre operadores lógicos:

Qualquer dúvida, só comentar.

Anterior << Estrutura Básica de um programa Java
Próximo >> Declaração de Variáveis

Estrutura da Linguagem

Laços de Repetição

Métodos

Chamadas de Métodos
Métodos "Void"
Métodos "Static"