Pular para o conteúdo principal

Estruturas de Controle em Java


Estruturas de Controle em Java

Ao construir uma aplicação, verá a necessidade de controlar o fluxo do sistema, blocos de instruções para solucionar um determinado problema.
Essa necessidade de controle deve-se ao fato de o fluxo poder se repetir ou em determinadas circunstancias nem mesmo precisar ser executado. Para isso temos as estruturas de controle que podem nos dar repetições simples, repetições condicionais e desvio de fluxo.
Em java existem alguns comando para efetuar controle de fluxo que são:

  • for
  • while
  • do while
  • if else
  • switch
  • break
  • continue
  • try
  • catch
  • finally
1.0 – Comando for
O comando “for” possui três parâmetros de controle, sendo todos opcionais e separados por “ponto e virgula” e delimitados por parênteses. Após a estrutura condicional declarada  vem o bloco de execução.
1
2
3
4
5
for ( [ início ]; [condição]; [incremento/decremento] ){
    ...
    /* bloco de execução aqui */
    ...
}
Exemplo
1
2
3
4
5
6
7
8
9
public class Exemplo1 {
    public static void main( String args[] ){
        int x;

        for ( x = 1; x <= 15; x++ ){
            System.out.println( x );
        }
    }
}
A saida do código acima, após compilado e executado, deverá ser uma exibição de números de 1 até 15 de acordo com as condições que passamos para a estrutura de controle, para x igual a 1 (um); enquanto x for menor ou igual a 15(quinze); x incrementará( ou seja x será igual a x mais 1(um) ).
Temos ainda a estrutura “for” para otimizar arranjos e coleções onde sua sintaze é:
1
2
3
4
5
for ( [Tipo] <variavel> :  <expressão> ){
    ...
    /* bloco de execução aqui */
    ...
}
Exemplo
1
2
3
4
5
6
7
8
9
public class Exemplo2 {
    public static void main( String args[] ){
        int vetor[] = {1, 4, 35, 10, 335, 675, 20, 50, 49, 6};

        for ( int x : vetor ){
            System.out.println( x );
        }
    }
}
A saida do código acima, após compilado e executado, deverá ser uma exibição dos números inteiros do arranjo com nome “vetor”. esta estrutura otimiza a interação no arranjo ou coleção passada para a espressão podendo ser efetuada a navegação sem a necessidade de índices ou interadores.
2.0 – Comando while
A comando “while” é executado enquanto a condição passada como parâmetro for verdadeira, vejamos:
1
2
3
4
5
while( [condição] ){
    ...
    /* bloco de execução aqui */
    ...
}
Exemplo
1
2
3
4
5
6
7
8
9
10
public class Exemplo3 {
    public static void main( String args[] ){
        int n = 10;

        while( n > 0 ){
            System.out.println( n );
            n--;
        }
    }
}
Reparem que “while” executa o bloco de código enquanto n for maior que zero, como internamente estmos decrementando “n” haverá dez iterações sendo executadas exibindo valores de números inteiros de 10(dez) a 1(um) na tela como saida do programa.
3.0 – Comando do while
A comando “do while” tem pelo menos uma iteração sendo executada pelo bloco de código a ele denominado tendo como condição verificada ao final como parametro passado para “while”
1
2
3
4
5
do{
    ...
    /* bloco de execução aqui */
    ...
}while( [condição] );
Exemplo
1
2
3
4
5
6
7
8
9
10
public class Exemplo4 {
    public static void main( String args[] ){
        int n = 10;

        do {
            System.out.println( n );
            n += 10;
        }while( n < 10 );
    }
}
Reparem que “do while” executa o bloco de código enquanto “n” for menor que 10(dez). O programa imprimira na tela apenas uma saída, o valor 10(dez) e em seguida abandonará o bloco de execução pois a condicional “n” menor que 10(dez) impedirá tal continuação.
Comando if else
Os comando “if” e “else”, podem desviar o fluxo do sistemas baseando-se em condicionais lógicos passados como parametros sendo “verdadeiros” ou “falsos” dependendo da expressão a eles denominados.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
if( [condição 1] ){
    ...
    /* bloco de execução aqui */
    ...
    if( [condição 1] ){
        ...
        /* bloco de execução aqui */
        ...
     }else if( [condição 2] ){
        ...
        /* bloco de execução aqui */
        ...
    }else{
        ...
        /* bloco de execução aqui */
        ...
    }
}else if( [condição 2] ){
    ...
    /* bloco de execução aqui */
    ...
}else{
    ...
    /* bloco de execução aqui */
    ...
    if( [condição 1] ){
        ...
        /* bloco de execução aqui */
        ...
    }else {
        ...
        /* bloco de execução aqui */
        ...
    }
}
Exemplo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Exemplo5 {
    public static void main( String args[] ){
        String name = "Nação Livre";

        if( ! name.equals( "Nação" ) ){
            int size = name.length;

            System.out.println( "Meu nome é: " + name );

            if( size > 0 ){
                System.out.println( "variavel 'name' com tamanho: " + 
                                           String.parseString( size ) + 
                                           " - bytes" );
            }

            System.exit( 0 );

        }else if( ! name.equals( "Nação Livre" ) ){
            System.out.println( "Meu nome é Nação Livre !!!" );
            System.exit( 0 );

        }else{
            System.out.println( "Quem Sou eu ?" );
            System.exit( 0 );
        }
    }
}
O código acima exibe a mensagem “Meu nome é: Nação Livre”, “variavel ‘name’ com tamanho: 11 – bytes” e logo em seguida encerra a aplicação. veja que podemos aninhar vários desvios condicionais e ainda colocar novos desvios condicionais dentro dos blocos “if” e “else”.
Comando switch
O comando “switch” possui um desvio condicional de multiplos casos de iterações baseando-se em sua expressão como denominadora do bloco de execução.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
switch( [ critério de entrada ] ){
    case [ caso 1 ]:
        ...
        /* bloco de execução aqui */
        ...
        break;

    case [ caso 2 ]:
        ...
        /* bloco de execução aqui */
        ...
        break;

    case [ caso N ]:
        ...
        /* bloco de execução aqui */
        ...
        break;

    default:
        ...
        /* bloco de execução aqui */
        ...
        break;
}
Exemplo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Exemplo6 {
    public static void main( String args[] ){
        if( args.length() > 0 ){
            switch( args[ 0 ].charAt( 0 ) ){
                case 'a':
                    System.out.println( "Você digitou a letra 'a'." );
                    break;

                case 'b':
                    System.out.println( "Você digitou a letra 'b'." );
                    break;

                case 'c':
                    System.out.println( "Você digitou a letra 'c'." );
                    break;

                default:
                    System.out.println( 
                        "Somente as letras [a|b|c] são aceitas." 
                    );
                    break;

            }
        }else {
            System.out.println(
                "Entre com um valor na linha de comando !!!"
            );
        }
    }
}
Comando break
O comando “break”, interrompe o fluxo normal do bloco de código em execução como “switch”, “for” e também “while” e “do while”.
1
2
3
4
5
6
7
for( x = 10; x < 20; x++ ){
    if( x == 15 ){
        break;
    }

    System.out.println( x );
}
O código acima executado imprimirá os valores de 10 (dez) até 14 (quatorze) e quando x for igual a 15 (quinze) a estrutura de repetição “for” será interrompida não dando sequência a sua execução.
Comando continue
O comando “continue”, interrompe o fluxo normal do bloco de código em execução como “switch”, “for” e também “while” e “do while”.
1
2
3
4
5
6
7
for( x = 0; x < 100; x++ ){
    if( x == 25 || x == 50 || x == 75 || x == 99 ){
        continue;
    }

    System.out.println( x );
}
O código acima ao ser executado imprimirá valores de 0 (zero) até 99 (noventa e nove), menos os valores 25 (vinte e cinco), 50 (cinquenta), 75 (setenta e cinco) e o número 99 noventa e nove, pois a condicional da estrutura de controle de fluxo “if”, faz com que seja feito um salto na estrutura de repetição “for”, fazendo assim com que os valores citados não seja exibidos na tela.
try, catch, finally, throw
A estrutura de controle de fluxo de código no java ainda oferece try, catch e finally que efetua tratamento de exceções disparados pelo sistema e sendo tratados pelo seu respectivo tipo de erro detectado.
Os comando “try” e “catch” trabalham juntos para delimitar a área de código a ser verificada e capturar a exceção ocorrida e desviando o fluxo natural do código para um tratamento especifico do tipo de dados disparado. Ainda podemos utilizar “finally” para garantir que sempre seja executado um determinado código ao final de “try” e “catch”.
Sendo assim, quando queremos provocar uma exceção, podemos disparar utilizando o comando “throw” para saltar o fluxo natural para a captura por “catch”.
Exemplo 7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 *
 * @author Nação Livre
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        try{
             int x = 10, y = 0;
             int r = x / y;

             System.out.println( v );
        }
    catch( Exception ex ){
            System.out.println( "Excetion: " + ex.getMessage() );
        }
    }
}
Quando compilar e executar o código acima, irá obter a seguinte saida: “Exception: / by zero”. Reparem que foi declarado um tipo genérico de dados “Exception” que captura genericamente exceções disparadas pelo sistema assim como poderia ter usado aqui ArithmeticException para capturar a exceção de aritmética .
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.sql.*;

public class MySQLConnect {
    public static void main (String args[] ){
        Connection conn = null;

        try{
            String username = "nacaolivre";
            String password = "senha54321";
            String url = "jdbc:mysql://localhost:3306/my_database/";

            Class.forName ("com.mysql.jdbc.Driver").newInstance ();
            conn = DriverManager.getConnection (url, username, password);

            System.out.println ("Sucesso na conexão !!!");
        }
        catch (Exception ex){
            System.err.println (
                "Erro estabelecendo conexão com o banco de dados !!!"
            );
        }
        finally{
            if (conn != null) {
                try {
                    conn.close ();
                }
                catch (Exception e) { 
                    // ...
                }
            }
        }
    }
}
Aqui reparem que foi incluido o comando “finally” juntamente com “try” e “catch”, ele verifica se a variavel “conn” que é um tipo de dado “Connection”, está conectado ao banco de dados, caso isto seja verdadeiro o método “close” é chamado para finalizar a conexão com o servidor de banco de dados MySQL. Veja que finally sempre será executado mesmo se a exceção for lançada por “try”.
As estruturas de controle de fluxo de código estão presentes em todas as linguagens de programação existentes, pois sem elas seria doloroso construir sistemas aplicativos tanto para desktop como para a web. Elas nos dão maneiras de estruturar um sistema minimizando código fonte e tornando-os mais inteligentes.
É isso ai, espero que tenham gostado.






Marcadores:
Local: Aparecida de Goiânia - GO, Brasil

Comentários

Postar um comentário

Postagens mais visitadas deste blog

Comandos Básicos em Java

C/C++. Este tópico apresenta de forma bem clara e resumida os principais comandos em Java e como eles devem ser usados. Vamos a eles: Declaração de Variáveis A declaração de variáveis é feita após a declaração da classe: public int numero; public String nome = "ForumWeb"; Comando if Executa um bloco de commando dependendo da condição: //sintaxe if (<condição>) <comando1> else <comando2> Comando switch Permite selecionar o trecho de código a ser executado a partir do valor de uma expressão switch(<expressão>) { case <valor1>: <comandos1>; break; case <valor2>:<comandos2>; break; case <valor n>:<commandos n>; break; default: <comandos_default>; } Laços de Repetição While Laço para a execução de código repetidas vezes (enquanto a condição de execução for verdadeira). A condição de execução do código é testada antes da primeira iteração. while(<condição>) { <comandos> } do Idêntico ao comando while, mas...
Postar um comentário
Leia mais
 Renato Lucena Área de desenvolvimento: Portfolio: www.renatolucena.net net Formações: iPED - Curso de PHP e MySql básico. Faculdade Delta - curso de Java desktop. Faculdade Sul Americana - Curso tecnólogo de desenvolvimento Java para web.(Java Server Pages) Prodata - Curso de Java Flex. iPED - Curso de PHP e MySql básico. Linux intermediário Aplicativos Mobile - Android...estudando. CEBRAC - Administração - 2015 Corel Draw básico. Curso Básico de JavaScript Conhecimento de Hardware e manuntençao. Conhecimento na plataforma Windows e um básico de Mac OX e instalação do hackintosh. Quero sucesso onde possa exercer minhas funções, crescendo e aprendendo cada vez mais, fazendo também a empresa crescer, consequentemente sempre está mudando de patamar para melhor.
Postar um comentário
Leia mais