Arrays em Java II

Nesta lição vamos estudar uns exemplos um pouco mais complexos, mas úteis em sua trajetória de programador. Se você tiver melhores soluções para estes exemplos ou tem dúvidas, comente!

Nós trabalharemos um pouco com Strings, que também são vetores, armazenam vários caracteres, em java é verdadeiras classes, diferente dos inteiros, flutuantes - float, reais - double e o próprio char. Só que aparentemente tratada como um simples tipo.

Prática

Neste exemplo, é feita a leitura de 5 Strings, onde será criados endereços de e-mail com estas Strings. Lembre e-mails são geralmente em minúsculas. O algoritmo automaticamente coloca os caracteres das Strings em minusculas.

import java.util.Scanner;

public class stringIncrement {
    public static void main(String[] args) {
        String nome[] = new String[5];
        String email[] = new String[5];
//Declaração e inicialização de variáveis
        char c = 'o';
        String minuscula = "";
        int i, j;
        Scanner input = new Scanner(System.in);
//Leitura das Strings
        for (i = 0; i < 5; i++) {
            System.out.println("Digite seu nome: ");
            nome[i] = input.next();
        }

        int n;
//1ºPasso é atribuído a n, o tamanho da string atual
//2ºPasso, c recebe o caractere atual
//3ºPasso, se o caracter está entre 65 - A e 90 - Z, é calculada a minúscula de c.
//4ºPasso, senão minuscula apenas acrescenta c aos caracteres
//5ºPasso, nome[i] recebe minuscula e minuscula recebe "" para se prontificar
//para a próxima String
//Entendeu? Daremos um outro exemplo que poderá lhe ajudar.
        for (i = 0; i < 5; i++) {
            n = nome[i].length();
            for (j = 0; j < n; j++) {
                c = nome[i].charAt(j);
                if ((nome[i].charAt(j) >= 'A') && (nome[i].charAt(j) <= 'Z'))
                    minuscula = minuscula + (char) (c + 32);
                else
                    minuscula = minuscula + c;
            }
            nome[i] = minuscula;
            minuscula = "";
        }
//E-mails prontos é TI e Palavra, rsrs.
        for (i = 0; i < 5; i++) {
            email[i] = nome[i] + "@tiepalavra.com";
            System.out.println("Nome: " + email[i]);
        }
    }

}

O alfabeto minúsculo e maiúsculo para você entender melhor sem vetores:

public class alfabeto {
    public static void main(String args[]) {
        char i;
        System.out.println("Alfabeto minúsculo");
        for (i = 97; i < 122; i++) {
            System.out.print(i + ", ");
        }
        i = 122;
        System.out.println(i + ".");
        System.out.println("Alfabeto maiúsculo");
        for (i = 65; i < 90; i++) {
            System.out.print(i + ", ");
        }
        i = 90;
        System.out.println(i + ".");
    }
}

Bom, no próximo exemplo é feita a leitura dos nomes dos alunos e as suas 3 notas, apartir daí é calculada a média, o total de pontos, a média geral, e o soma geral dos pontos:

import java.util.Scanner;

public class alunoMedia {
    public static void main(String[] args) {

//Cada aluno tem o seu nome, a sua 1º - 3º notas individualmente.

//Vetores Declarados
        String aluno[] = new String[5];
        int notas1[] = new int[5];
        int notas2[] = new int[5];
        int notas3[] = new int[5];
        float soma[] = new float[5];
        float media[] = new float[5];
        int qtd, i;

//A divisão de números inteiros nem sempre resulta em números inteiros

//Tipo float para resolver este detalhe
        float somaGeral = 0, mediaGeral;
        Scanner input = new Scanner(System.in);
        System.out.println("Quantos alunos deseja cadastrar: ");
        qtd = input.nextInt();

//Leitura dos nomes e notas, conforme o laço.
        for (i = 0; i < qtd; i++) {
            System.out.println("Digite o nome do aluno: ");
            aluno[i] = input.next();
            System.out.println("Digite a primeira nota: ");
            notas1[i] = input.nextInt();
            System.out.println("Digite a segunda nota: ");
            notas2[i] = input.nextInt();
            System.out.println("Digite a terceira nota: ");
            notas3[i] = input.nextInt();

//Calculo da soma e media individual
            soma[i] = notas1[i] + notas2[i] + notas3[i];
            media[i] = soma[i] / 3;

//somaGeral
            somaGeral = somaGeral + soma[i];

        }

//mediaGeral
        mediaGeral = somaGeral / (3 * qtd);

//Resultado da soma e media geral
        System.out.println("soma geral: " + somaGeral);
        System.out.println("media geral: " + mediaGeral);
//Aqui é listado os alunos e as notas

//Há um porém se você colocar para cadastrar apenas um aluno, não é listada as informações
        for (i = 0; i < qtd - 1; i++) {
            if (i % 2 == 0) {
                System.out.print("\nAluno: " + aluno[i]);
                System.out.println("\t\t\t\tAluno: " + aluno[i + 1]);

                System.out.print("primeira nota: " + notas1[i]);
                System.out.println("\t\t\tprimeira nota: " + notas1[i + 1]);

                System.out.print("Segunda nota: " + notas2[i]);
                System.out.println("\t\t\t\tSegunda nota: " + notas2[i + 1]);

                System.out.print("Terceira nota: " + notas3[i]);
                System.out.println("\t\t\tTerceira nota: " + notas3[i + 1]);

                System.out.print("Média do aluno: " + media[i]);
                System.out.println("\t\t\tMédia do aluno: " + media[i + 1]);

                System.out.print("Soma de pontos do aluno: " + soma[i]);
                System.out.println("\t\tSoma de pontos do aluno: "+ soma[i + 1] + "\n");
            }

        }

    }
}

Para melhor programação de algoritmos mais completos é necessário, modularizá-los. Precisaremos da orientação a objetos para aperfeiçoar o alunoMedia. Postaremos sobre a Orientação a objetos em Java. Acompanhe nosso blog!

Arrays em Java I

Nesta lição vamos aprender a usar os vetores(arrays), que são são estruturas de dados que armazenam uma quantidade predefinida de dados de um mesmo tipo. No exemplo abaixo, declarei o array do tipo inteiro de 5 posições. Por convenção, as posições iniciam apartir do 0. Veja:

int vetor = new int[5];
vetor[0] = 6;
vetor[1] = 3;
vetor[2] = 2;
vetor[3] = 9;
vetor[4] = 16;

 A grande vantagem dos vetores é que você não precisa declarar várias variáveis do mesmo tipo para um objetivo em comum. Você não precisa declarar:

int vetor1, vetor2, vetor3, vetor4, vetor5;

E você pode usar os laços de repetição para uma programação mais ágil e fácil. Basta você compreender e você estará programando com boa afinidade.

Prática

Neste exemplo é feita a leitura de 10 números inteiros e exibição destes números:

import java.util.Scanner;

public class lerVetor {
    public static void main(String[] args) {
//Declaração do array do tipo inteiro de 10 posições
        int vetor[] = new int[10];
        Scanner input = new Scanner(System.in);
//Leitura
        for (int i = 0; i < 10; i++) {
            System.out.println("Digite o elemento do vetor[" + i + "]: ");
            vetor[i] = input.nextInt();
        }
//Mostra os números inteiros lidos
        for (int i = 0; i < 10; i++) {
            System.out.println("vetor[" + i + "]: " + vetor[i]);
        }
    }

}

 No algoritmo abaixo se tem um trecho de código bastante conhecido, ele ordena uma sequência de números em um vetor:

import java.util.Scanner;

public class ordenaVetor {
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        int array[] = new int[10];

//Leitura
        for (int i = 0; i < 10; i++) {
            System.out.println("Informe o numero " + i + ":");
            array[i] = input.nextInt();
        }
        int i, j, aux;

//Ordenação do vetor

//No caso não foi usado as chaves pois o for executa a linha abaixo, e assim sucessivamente

//A ordenação é decrescente - (array[i] < array[j])

//Para ordenação crescente - (array[i] > array[j]) - simples
        for (i = 0; i < 10; i++)
            for (j = i + 1; j < 10; j++)
                if (array[i] < array[j]) {
                    aux = array[i];
                    array[i] = array[j];
                    array[j] = aux;

                }
        System.out.println("Numeros Ordenados: ");

//Pode se usar o for desta maneira também!
        for (int numero : array) {
            System.out.println(numero);
        }
    }
}

Neste exemplo, é feita a leitura de 5 números, e o algoritmo mostrará a média, o maior, o menor, o número de elementos maiores que 5 e a porcentagem dos números maiores que 5:

import java.text.DecimalFormat;
import java.util.Scanner;

public class mediaVetor {
    public static void main(String[] args) {
        int vetor[] = new int[5];
        int i, maior = 0, menor = 10000, qtdm = 0;
        float media = 0, soma = 0;
        Scanner input = new Scanner(System.in); 

//Leitura dos elementos
        for (i = 0; i < 5; i++) {
            System.out.println("Digite o " + i + "º elemento");
            vetor[i] = input.nextInt();
        }
//Verificação do maior, do menor, e da quantidade elementos>5
//A verificação do maior e do menor funciona assim:
//Maior = 0, quando certo elemento é maior do que ele é armazenado o novo
//valor maior, e é assim também com o menor.
//Quanto ao qtdm é usada a incrementação cada vez que a condição é verdadeira
        for (i = 0; i < 5; i++) {
            soma = soma + vetor[i];
            if (vetor[i] > maior) {
                maior = vetor[i];
            }
            if (vetor[i] < menor) {
                menor = vetor[i];
            }
            if (vetor[i] > 5) {
                qtdm++;
            }
        }
//Esta foi uma solução para o número racional que viria da porcentagem
//Então ele não permite - 00,00 - no caso ele permite apenas 00
//Nas bibliotecas importadas temos: import java.text.DecimalFormat;
//Que me permite usar esta ferramenta.
        DecimalFormat df = new DecimalFormat();
        df.applyPattern("00;(00)");
        float porc = (qtdm * 100) / 5;
        media = soma / 5;
        System.out.println("A média é: " + media);
        System.out.println("O maior é: " + maior);
        System.out.println("O maior é: " + menor);
        System.out.println("O número de elementos maiores que 5 é: " + qtdm);
        System.out.print("Porcentagem dos elementos maiores que 5 é: "+ df.format(porc)+"%");
    }

}

Espero que compreendam o uso dos vetores, arrays, e como você pode está filtrando os elementos, ordenando, mostrando os valores como pedido e a informação que estes dados podem te dar. Comente!

Estruturas de Repetição II

Nesta lição vamos aprender a usar as estruturas de repetição while e do-while.

while quer dizer enquanto. Funciona da seguinte maneira enquanto a condição é verdadeira o laço é executado repetidas vezes. Vejamos a estrutura:

while (CONDIÇÃO){

           INSTRUÇÕES

}

Diferente do for o while tem só a condição como critério de repetição. Enquanto a condição é verdadeira o laço acontece, quando a condição for falsa o laço parará de executar as instruções.

Do quer dizer fazer. O algoritmo executa primeiro para depois conferir a condição. Esta é a vantagem: As instruções são executadas pelo menos uma vez com o do-while. Vejamos:

do{

      INSTRUÇÕES

     }while(CONDIÇÃO);

O incremento no caso do while e do-while acontece dentro das instruções, ou alguma leitura contradiz a condição. Às vezes o seu while pode ter uma condição sempre verdadeira, então ele sempre repetirá as instruções, mas é sempre bom ter uma condição de parada acessível para o usuário.

Prática

No exemplo a seguir teremos um algoritmo que separa em colunas os números pares e os números ímpares:

public class whileImpar {
    public static void main(String[] args) {

        int i = 0;
        System.out.println("Números impares e pares");

//Observe que usei o \t para esse efeito.

//É como o TAB que usamos para espaçamento.
        System.out.println("Pares \tImpares");

//i é 0, i será incrementado em i+=1 até ter valor 10, a condição será satisfeita e fim do laço.

//i % 2 == 0, todo número par dividido por 2, terá resto 0.

//i % 2 == 1, todo número impar dividido por 2, terá resto 1.
        while (i <= 10) {
            if (i % 2 == 0) {
                System.out.print(i);
            }
            if (i % 2 == 1) {
                System.out.println("\t" + i);
            }
            i++;
        }
    }

}

No exemplo abaixo, o usuário verá um menu com as opções de cadastrar, ver cadastro e sair:

import java.util.Scanner;

public class whileMenu {
    public static void main(String[] args) {
        int escolha = 1, idade = 0;
        String nome = "";
        Scanner input = new Scanner(System.in);

//De acordo com o que vimos do conceito de while e do-while

//Aqui poderia ser usado o do-while tranquilamente, já que escolha é inicializado acima com 1
        while (escolha == 1) {
            System.out.println("Bem-vindo ao JoyaSoftware!");
            System.out.println("1 - Cadastrar");
            System.out.println("2 - Ver Cadastro");
            System.out.println("3 - Sair");
            int opcao = input.nextInt();

//Usei o switch-case para atender as opções do menu
            switch (opcao) {
            case 1:
                if (idade == 0 || nome == "") {
                    System.out.println("Digite seu nome: ");
                    nome = input.next();
                    System.out.println("Digite sua idade: ");
                    idade = input.nextInt();
                } else {

//Que pena! ainda não estudamos arrays ou ainda arraylist. Risos!
                    System.out.println("Você já preencheu o cadastro!");
                    System.out.println("digite um caractere e dê enter para voltar.");

//nenhuma variável receberá a leitura do caractere ou palavra que o usuário digitar
                    input.next();
                }
                break;
            case 2:
                System.out.println("Nome: " + nome);
                System.out.println("idade: " + idade);
                System.out.println("digite um caractere e dê enter para voltar.");
                input.next();
                break;
            default:

//lembre while(escolha == 1), se escolha receber 2 a condição será falsa.
                escolha = 2;
            }
        }

    }

}

Este algoritmo pede a leitura de 2 números, sendo que o 1º número só recebe números naturais maiores que

100 e o 2º número os menores que 20:

import java.util.Scanner;

public class dowhileMaior {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int num1 = 0, num2 = 0;

//Leitura do 1º número, executando uma vez e sempre retornando se num1<100
        do {
            System.out.println("Informe um número natural maior que 100: ");
            num1 = input.nextInt();

        } while (num1 < 100);

//Leitura do 2º número, executando uma vez e sempre retornando se num2>20
        do {
            System.out.println("Informe um número natural menor que 20: ");
            num2 = input.nextInt();

        } while (num2 > 20);
    }

}

Neste exemplo o algoritmo concede ao usuário uma condição de parada, onde ele pode sair do programa:

import java.util.Scanner;
public class dowhileSair {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        String nome;
        int sair=1;

//Leitura do seu nome
        System.out.println("Digite seu nome: ");
        nome = input.next();
//Esta condição de parada é muito usada quando o usuário pode digitar

//vários números e pode parar digitando 0 ou ainda -1.

//Ele pode digitar quantos números ele quiser.       
        do{
            System.out.println("Bem vindo, "+nome+" ao do While!");
            System.out.println("Para sair a condição deverá ser falsa!");
            System.out.println("Digite 0 e pressione enter para sair!");
            sair = input.nextInt();

//Enquanto sair é diferente de 0 retorne a executar o laço.
        }while(sair != 0);
    }

}

Bom, terminamos com esta lição o tópico das estruturas de repetição. Aguardem iremos aprender nas próximas aulas sobre vetores(arrays).

Tito 2:11-13
11 - Porque a graça de Deus se há manifestado, trazendo salvação a todos os homens,
12 - Ensinando-nos que, renunciando à impiedade e às concupiscências mundanas, vivamos neste presente século sóbria, e justa, e piamente,
13 - Aguardando a bem-aventurada esperança e o aparecimento da glória do grande Deus e nosso Salvador Jesus Cristo;

Estruturas de Repetição I

Nesta lição vamos ver a estrutura de repetição for. A estrutura de repetição for inicia de um valor inicial e vai até o valor predefinido. Como funciona:

for (INICIALIZAÇÃO DE VARIÁVEIS; CONDIÇÃO; INCREMENTO){

      INSTRUÇÕES

}

Na inicialização de variáveis podemos inicializar nossas variáveis participantes do for, mas na imensa maioria apenas inicializamos somente uma variável.

Na condição podemos colocar a condição de parada do for, estando verdadeira esta condição o laço continua executando as estruções repetidas vezes.

No incremento podemos incrementar as variáveis participantes do for, como a inicialização apenas incrementamos apenas uma variável.

for (int i=1; i<=5; i++){
instruções
}

 No exemplo acima i é nossa variável inicializada com 1 que será incrementada em +1 toda vez que as instruções do for tiverem sido executadas. Qual o intervalo de i<=5?

Pense...Reflita...Analise...Observe...

Pense...Reflita...Analise...Observe...

Risos! Para começar ver qual o intervalo de i<=5, precisamos identificar i que é igual a 1 e que a cada vez que as instruções são executadas soma-se 1 a i. O intervalo = {1, 2, 3, 4, 5}. 

 Então, teremos as instruções executadas 5 vezes. 

E se o incremento ser i = i+2? O intervalo = {1, 3, 5}.

As instruções serão executadas 3 vezes.

Well, é necessário ter bastante noção de como usar o for para não calcular errado, quantas vezes será executadas as instruções. Você deve saber que dispõe de outros recursos, no qual especificará como essas instruções serão executadas. 

Como: 

• if - somente as condições verdadeiras serão executadas.
• else - caso o if sendo falso, else é executado.
• break - dentro de um if, se determinada condição ser verdadeira, executa break, que sai do laço, independente da condição do for ser satisfeita.

Prática

Para começar, veremos um pequeno programa que faz a contagem de 1 a 10 com o for:

//Exemplo simples de for no intervalo de 1 a 10.
//O sysout é executado 10 vezes, sempre com o valor de i atualizado.
public class forCont {
    public static void main(String[] args) {
        System.out.println("Contagem de 1 a 10!");
        for (int i= 1; i <= 10; i++) {
            System.out.println(i);
        }
    }
}

 No exemplo seguinte, quero que sejam mostrados todos os números entre a e b:

import java.util.Scanner;

public class forInter {
    public static void main(String[] args) {
        int a, b;
        Scanner input = new Scanner(System.in);
//Leitura de a e b.
        System.out.println("Digite um número(a): ");
        a = input.nextInt();
        System.out.println("Digite um número(b): ");
        b = input.nextInt();
//Ocorre que a pode ser maior que b, menor que b, ou igual a b, por isso o if-else
//Se a é maior que b, b não pode ser contado com seu valor original, exemplo: a = 7, b=4.
//b++ ou  b= b+1, b é incializado dessa maneira b será 5, e o intervalo = {5, 6}.
        if (a > b) {
            for (b++; a > b; b++) {
                System.out.println(b);
            }
        } 
//Se b é maior que a, procede como b, acima.
            else if (a < b) {
            for (a++; a < b; a++) {
                System.out.println(a);
            }
        } 
//Se a é igual a b, uma mensagem ao usuário diz:  "Não existe números inteiros entre a e b."
            else if (a == b) {
            System.out.println("Não existe números inteiros entre a e b.");
        }
    }
}

 Now, exemplo abaixo, Vamos calcular a fatorial de um número:

import java.util.Scanner;

public class forFatorial {
    public static void main(String[] args) {
        int numero;
        Scanner input = new Scanner(System.in);
//Leitura do número
        System.out.println("Digite um número: ");
        numero = input.nextInt();
//Criação de variável fat inicializada com 1
        int fat = 1;
//i=1, se na leitura digitar 5, i será incrementado até 5. então fat = 1x2x3x4x5.
//Há como fazer o processo inverso, fat = 5x4x3x2x1.
//Veja  ---->>>         for (int i = numero; i >= 1; i--) {

        for (int i = 1; i <= numero; i++) {
            fat = fat * i;
        }
        System.out.println("A fatorial do número " + numero + " é: " + fat);
    }
}

Queria trazer algum exemplo com String, neste exemplo o programa pede o seu nome, e é contado quantos caracteres tem no seu nome. Foi usado o length() que significa comprimento. Vejamos:

import java.util.Scanner;

public class forName {
    public static void main(String[] args) {
        String nome;
        int tam;
        Scanner input = new Scanner(System.in);
//Leitura do nome
        System.out.println("Digite seu nome: ");
        nome = input.next();
//o inteiro tam recebe o comprimento de nome.
        tam = nome.length();
        System.out.println("");
//Uma * para cada caractere
        for (int i = 1; i <= tam; i++) {
            System.out.print("*");
        }
        System.out.println("\n" + nome);
        for (int i = 1; i <= tam; i++) {
            System.out.print("*");
        }
    }

}

Exemplo: Digite seu nome: Renan

O programa fará isso:

*****
Renan
*****

Espero que tenham compreendido tanto do funcionamento da estrutura de repetição, bem como de sua implementação.

Na próxima lição iremos estudar mais as Estruturas de Repetição II. Bons Estudos!

Operadores Lógicos e Condicionais II

Nesta Lição, eu quero mostrar como o switch é mais apropriado no caso de menus, pois o código com switch é mais simplificado e objetivo, reduzindo assim o código.

Vejamos este símples exemplo:

import java.util.Scanner;

public class menuIf {
    public static void main(String[] args) {

//Usaremos três variáveis, uma variável inteira e duas Strings
//A principal será a variável escolha, onde o usuário informará ao programa se ele deseja
//iniciar, ver os créditos ou sair
        int escolha = 0;
        String nome = "";
        String voltar;
        Scanner input = new Scanner(System.in);
//Através deste while acessaremos o menu todas as vezez, exceto quando informado 3
//Lembrando que ainda não vimos while em nossas lições que é uma estrutura de repetição
        while (escolha != 3) {
            System.out.println("Menu if");
            System.out.println("1.Iniciar \n" + "2.Créditos \n" + "3.Sair");
            escolha = input.nextInt();
//Se escolha é igual a 1 faça
            if (escolha == 1) {
                System.out.println("Você acaba de iniciar este programa");
                System.out.println("Digite seu nome: ");
                nome = input.next();
                System.out.println("Olá! " + nome);
            }
//Se escolha é igual a 2 faça
            if (escolha == 2) {
                System.out.println("Créditos: by Renan Raphael");
                System.out.println("Digite voltar");
                voltar = input.next();
            }
//Se escolha é igual a 3 faça
            if (escolha == 3) {
                System.out.println("Saindo...");
            }
        }
    }

}

E agora veremos este mesmo exemplo com switch:

import java.util.Scanner;

public class switchCase {

    public static void main(String[] args) {
//Nossas variáveis
        int escolha = 0;
        String nome = "";
        String voltar;
        Scanner input = new Scanner(System.in);
//Estrutura de repetição while para o menu
        while (escolha != 3) {
            System.out.println("Menu");
            System.out.println("1.Iniciar \n" + "2.Créditos \n" + "3.Sair");
            escolha = input.nextInt();
//switch, onde através do valor da variável escolha, teremos executado um dos casos
            switch (escolha) {
//caso escolha seja 1
            case 1:
                System.out.println("Você acaba de iniciar este programa");
                System.out.println("Digite seu nome: ");
                nome = input.next();
                System.out.println("Olá! " + nome);
                break;
//break quebra a leitura do switch, impedindo que outros cases sejam executados,
//ou seja, o case 1 será executado, mas não o case 2 e 3.
            case 2:
                System.out.println("Créditos: by Renan Raphael");
                System.out.println("Digite voltar");
                voltar = input.next();
                break;
//qualquer valor diferente de 1 e 2 é executado default

//mas para sair tanto switch como do while teria que ser usado o valor 3 para escolha
            default:
                System.out.println("Saindo...");
                break;

            }

        }
    }

}

É bem útil usar switch para menus, pois facilita o entendimento do código.
Bem vejamos  even now este exemplo:

import java.util.Scanner;

public class switchImpar {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
//Nossa variável número irá receber um número de 1 a 10 somente
        int numero = 0;
//Este while intrometido descarta a opção de informar um valor menor do que 1, ou maior que 10
//Este while implementado...
        while (numero < 1 || numero > 10) {
            System.out.println("Digite um número de 1 a 10: ");
            numero = input.nextInt();
        }
//Bom aqui nós temos o switch, onde será visto se o número é impar ou par
//O case pode ser feito dessa forma: 1, 3, 5, 7, 9 são todos ímpares e 2, 4, 6, 8, 10 são todos pares
        switch (numero) {
        case 1:
        case 3:
        case 5:
        case 7:
        case 9:
            System.out.println("O número é ímpar!");
            break;
        case 2:
        case 4:
        case 6:
        case 8:
        case 10:
            System.out.println("O número é par!");
        }
    }

}

No exemplo acima, ainda é uma boa opção, mas usando o if com cálculos aritméticos é bem melhor,

vamos observar:

import java.util.Scanner;

public class ifImpar {
    public static void main(String[] args) {
//A variável numero deve ser inicializada com 0, pois a princípio numero deve ser diferente de 1,2,...,10
        int numero = 0;
        Scanner input = new Scanner(System.in);
//Estrutura de repetição para a leitura do número
        while (numero < 1 || numero > 10) {
            System.out.println("Digite um número de 1 a 10");
            numero = input.nextInt();
        }
///Se numero dividido por 2 obterá resto igual a 1, este número é ímpar
        if (numero % 2 == 1) {
            System.out.println("O número é ímpar");
        }
//Se numero dividido por 2 obterá resto igual a 0, este número é par
        if (numero % 2 == 0) {
            System.out.println("O número é par");
        }
    }

}

Bom termimos a lição de Operadores Lógicos e Condicionais II. Na próxima lição iremos estudar as Estruturas de Repetição I. Comente esta lição!

O amor seja não fingido. Aborrecei o mal e apegai-vos ao bem.
Romanos 12:9

O amor seja não fingido. Aborrecei o mal e apegai-vos ao bem.
Romanos 12:9

 Romanos 12:09 

09 - O amor seja não fingido. Aborrecei o mal e apegai-vos ao bem.

O amor seja não fingido. Aborrecei o mal e apegai-vos ao bem.
Romanos 12:9

O amor seja não fingido. Aborrecei o mal e apegai-vos ao bem.
Romanos 12:9

Operadores Lógicos e Condicionais I

Operadores Lógicos

Bem temos várias operações lógicas que é preciso nos familiarizar. As Principais são:

Operador e, and, &&

A	B	A && B
V	V	V
V	F	F
F	V	F
F	F	F

Operador Ou, or, ||

A	B	A || B
V	V	V
V	F	V
F	V	V
F	F	F

Operador !(negação de _)

A	!A
V	F
F	V

Operadores Condicionais

Agora que já temos a noção dos operadores lógicos, veremos os operadores condicionais, que precisam de uma condição para ser executada, e caso essa condição seja satisfeita as linhas de código entre as chaves {} são mostrados os seus resultados.

Supomos o seguinte: Que você irá pegar um ônibus na rodoviária, para a cidade do Rio de //Janeiro, e a valor da passagem é paga por pessoas maiores de 8 anos, e para as pessoas //menores de 8 anos não é cobrado o valor da passagem. Você está acompanhado.

import java.util.Scanner;

public class operadoresLogicos {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int idade;
        System.out.println("Qual a sua idade: ");
        idade = input.nextInt();
        if (idade >= 8) {
            System.out.println("Valor de passagem: 130,00 ");
        }
        if (idade < 8) {
            System.out.println("Não é cobrado o valor da passagem.");
        }
    }
}// Fim do c ódigo

Supomos outra vez: Estão contratando pessoas para um trabalho mirim, e é tido como condições que para ser admitido o cidadão deve ser estudante e maior de 16 anos.

import java.util.Scanner;

public class operadoresLogicos2 {
    public static void main(String[] args) {
        int idade, condicao;
        Scanner input = new Scanner(System.in);
        System.out.println("Sua idade: ");
        idade = input.nextInt();
        System.out.println("Estudando: ");
        System.out.println("1(sim) 2(não)");
        condicao = input.nextInt();
        if (idade >= 16 && condicao == 1) {
            System.out.println("Você satisfaz as nossas condições");
        }
        else {
            System.out.println("Você não satisfaz as nossas condições");
        }
    }
}

Suponhamos que: Numa fila de banco pessoas idosos, grávidas, pessoas com crianças decolo ou deficientes físicos, precisam de atendimento diferenciado e rápido.

import java.util.Scanner;

public class operadoresLogicos3 {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int condicao;
        System.out.println("Qual a situação do cliente: ");
        System.out.println("1(idoso(a))  \n" +
                "2(mulher grávida)\n" +
                        "3(pessoa com criança de colo) \n" +
                        "4(deficiente físico) \n" +
                        "5(outro)");
        condicao = input.nextInt();
        if (condicao == 1 || condicao == 2 || condicao == 3 || condicao == 4) {
            System.out.println("Atendimento rápido e diferenciado.");
        }
        else {
            System.out.println("Atendimento comum. Esperar a fila para ser atendido.");
        }
    }
}

Na próxima lição iremos aprender mais dos Operadores Lógicos e Condicionais II. Comente esta lição!