Vamos agora abordar os metacaracteres tipo âncora. Inicialmente, por que a nomenclatura âncora? Porque eles não definem caracteres ou casam quantidades, no lugar disso eles marcam uma posição específica na linha. Veremos o primeiro metacaractere-âncora, que é o circunflexo.

^[0-9]  buscamos linhas que começam com números. Observe o código.

Pattern p = Pattern.compile(“^[0-9].*”);

Matcher m = p.matcher(“787Devmedia”);

Saída:

Padrão: ^[0-9]

0 787Devmedia

^[^0-9] buscamos linhas que não começam com números. O 1º circunflexo é a âncora e o 2º é a negação da lista.

Complementar e semelhante ao circunflexo, o cifrão marca o fim de uma linha e só é válido no fim da expressão. Como o exemplo acima, [0-9]$ combina com linhas finalizadas com um número.

Agora que vimos um pouco mais sobre regex, os códigos de exemplo farão bem mais sentido. Eis um exemplo mais complexo de uma fonte e de uma expressão:

Pattern p = Pattern.compile(“aba”);

Matcher m = p.matcher(“abababa”);

Avaliaremos qual seria a regexp para casar com um horário, por exemplo, 22:56.

[0123456789][0123456789]:[0123456789][0123456789]

Pattern p = Pattern.compile(“[0123456789][0123456789]:[0123456789][0123456789]”);

Matcher m = p.matcher (“O horário é 22:56”);

Saída:

Padrão: [0123456789][0123456789]:[0123456789][0123456789]

12 22:56

Entretanto, ainda não está 100%, pois se o Matcher fosse 77:77 haveria casamento ou coincidência, e temos ciência que essa não é uma hora válida.

Como iria ser uma regexp que casasse precisamente somente uma letra minúscula, maiúscula uma e números? Solução:

[a-zA-Z0-9]

Imaginemos a seguinte situação: o Matcher é 14-45 12345. Qual seria o Pattern para casá-lo. De modo óbvio, a dificuldade é o traço, que é especial. Então observe como resolver esse problema.

Pattern p = Pattern.compile(“[0-9][0-9]:[0-9][0-9]”);

Matcher m = p.matcher (“22-46 98765”);

Saída:

Padrão: [0-9][0-9]:[0-9][0-9]

0 22-46

6 98765

Lista negada

A lista negada tem uma lógica inversa. Observe que a diferença em sua notação é que o 1º caractere da lista é um circunflexo.

Pattern p = Pattern.compile(“[^Xxx]”);

Matcher m = p.matcher (“XxxY”);

Padrão: [^Xxx]

3 Y

Vejamos agora o segundo tipo de metacaracteres, que são os quantificadores, que são úteis para indicar o número de repetições permitidas para a entidade prontamente anterior. Eles dizem a quantidade de vezes que o átomo anterior pode aparecer e quantas repetições pode ter.

Continuemos com um exemplo do opcional (?). Observe que sigamos primeiramente a sequência: primeiro lê-se o átomo por átomo, após compreende-se o todo e depois se analisam as probabilidades. Avaliemos a expressão:

canta[r!]?

Fica um c seguido de um a seguido de um n seguido de um t seguido de um a, seguido de um r,ou ! ou ambos opcionais. Veremos ver como fica em um código .

Pattern p = Pattern.compile(“canta[r!]?”);

Matcher m = p.matcher(“Preciso cantar, canta, cantar!, canta!”);

Saída:

O padrão é: fala[r!]?

8 cantar

16 canta

23 cantar

32 canta!

O opcional (?) proporciona que a entidade anterior esteja presente ou não, o asterisco é ainda mais permissivo, uma vez que, para ele, pode existir, não existir, ou não existir diversos. Ou seja: a entidade anterior pode aparecer em qualquer quantidade.

Expressões Regulares

Uma expressão regular é um modelo formal de apontar um padrão de texto. De modo mais específico, é uma composição de caracteres e símbolos com funções especiais que, quando reunidos entre si e com caracteres literais, formam uma sequência, ou seja, uma expressão.

Essa expressão será avaliada como uma regra que sinalizará sucesso se uma entrada de dados qualquer combinar com essa regra.

Veja com muita atenção o exemplo e a saída. Em seguida explicaremos outros detalhes da sintaxe Java para o uso de regexps.

package devmedia;

 

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 

public class ExpressaoRegex {

 

      /**

       * @param args

       */

      public static void main(String[] args) {

            Pattern p = Pattern.compile("e.tende");

            Matcher m = p.matcher("Subclasse estende a Superclasse");

           

            boolean b = false;

            System.out.println("Padrão: "+m.pattern());

            while(b = m.find()){

                  System.out.println(m.start()+" "+m.group());

            }

            System.out.println();

            Pattern p1 = Pattern.compile("23.34");

            Matcher m1 = p1.matcher("Já são 23:34.");

            boolean b1 = false;

            System.out.println("Padrão: "+m1.pattern());

            while(b1 = m1.find()){

                  System.out.println(m1.start()+" "+m1.group());

            }

           

 

      }

 

}

Saída:

Padrão: e.tende

10 estende

 

O padrão é: 23.34

7 23:34

Analisaremos outro metacaractere de representação: a lista [...]. Ela possui total consciência do que quer e nada diferente daquilo casa com quem ela tem conhecimento. Observe o código a seguir:

package devmedia;

 

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 

public class ExpressaoRegex {

 

      /**

       * @param args

       */

      public static void main(String[] args) {

            Pattern p = Pattern.compile("e[xs]tende");

            Matcher m = p.matcher("Subclasse estende e/ou extende a Superclasse?");

           

            boolean b = false;

            System.out.println("Padrão: "+m.pattern());

            while(b = m.find()){

                  System.out.println(m.start()+" "+m.group());

            }

 

      }

 

}

Saída:

Padrão: e[xs]tende

10 estende

23 extende

Vimos, até agora, o básico da sintaxe Java para regexps, vamos mostrar na tabela abaixo o Pattern e os Matchers possíveis.

5. Com o seguinte código:

package devmedia;

import java.io.File;

import java.io.IOException;

public class Teste {

      /**

       * @param args

       */

      public static void main(String[] args) {

            try {

                  new File("file.txt").createNewFile();

            } catch (IOException e) {

                  e.printStackTrace();

            }

      }

}

O que ocorre?

a) O coletor de lixo pode entrar em ação para coletar o arquivo.

b)É criado um arquivo sem uma referência

c)Não é possível referenciar o arquivo criado

d)O arquivo não pode ser usado, uma vez que nenhuma referência aponta para ele

e) É criada uma referência sem arquivo

f)Essa sintaxe de criação de arquivos não é valida

6. Dado o seguinte trecho de código:

Writer wr = new BufferWriter(xxx);

O que pode ficar no lugar de xxx?

a) new BufferedWriter(new FileWriter(new File(“arq.txt”)));

b) new File(“arq.txt”);

c) new FileWriter(“arq.txt”);

d) new PrintWriter(new File(“arq.txt”));

e) new FileReader(“arq.txt”);

7. Observe:

package devmedia;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;

class Automovel {

      String marca="DM";

}

class Carro extends Automovel implements Serializable{

      int numPortas = 5;

}

public class TesteSerializacao {

      /**

       * @param args

       */

      public static void main(String[] args) {

            Carro c = new Carro();

            c.marca="Java";

            System.out.print(c.marca);

            try{

                  FileOutputStream fos = new FileOutputStream("teste.txt");

                  ObjectOutputStream os = new ObjectOutputStream(fos);

                  os.writeObject(c);

                  os.close();

                  FileInputStream fis = new FileInputStream("teste.txt");

                  ObjectInputStream oi=new ObjectInputStream(fis);

                  c = (Carro)oi.readObject();

                  oi.close();

            }catch (Exception e) {

                  e.printStackTrace();

            }

            System.out.print(c.marca);

      }

}

Qual é a saída?

a)Java Java

b)DM Java

c)DM DM

Mini-teste

1. Dado:

package devmedia;

public class StringTeste {

      public static void main(String args[]){

            StringBuffer buffer = new StringBuffer("123");

            sb.append("456").reverse().insert(2, "…");

            System.out.println("strbuffer: "+ buffer);

      }

}

Quantos objetos foram criados ao executar esse código?

a)1

b)2

c)3

d) Nenhum

e)Não compila

f)É lançada uma Exception

2. Quais declarações sobre as classes String, StringBuffer e StringBuilder são corretas?

a) Todas as três classes têm métodos append() sobrecarregados.

b) O “+” é um operador sobrecarregado para as três classes.

c) Todas as três classes têm um método lenght().

d) Os objetos do tipo StringBuffer são seguros em relação aos threads.

e) De acordo com a API, StringBuffer será mais rápida do que StringBuilder na maioria das implementações.

f) O valor de uma instância de qualquer um desses três tipos pode ser modificado por meio de vários métodos da API.

3. Observe o seguinte código:

package devmedia;

public class Main {

      /**

       * @param args

       */

      public static void main(String[] args) {

            String e="-";

            Integer x = 343;

            long L343 = 343L;

            if(x.equals(L343))e+=".a1";

          &

Console

A classe java.io.Console foi inserida no Java 6. Console quer dizer um dispositivo com um teclado e uma tela. Podemos compreender um console como um computador.

Uma referência desse objeto pode ser adquirida por meio do método estático System.console().

A classe Console ainda permite escrever saídas formatadas para a linha de comando.

Do ponto de vista da entrada de dados, é necessário entender o funcionamento dos métodos readLine() e readPassword(). O método readLine() retorna uma String contendo tudo o que o usuário digitou.

Porém, o método readPassword() não retorna uma String e sim um array de char. Esse é o motivo pelo qual, uma vez que se tenha obtido a senha, é possível verificá-la e retirá-la da memória. Se uma String fosse retornada, ela poderia existir em um pool pertencente a algum local na memória e ser encontrada.

package devmedia;
import java.io.Console;
class Utils{
      String fazerAlgo(String arg1){
            return "Valor de parametro: "+arg1;
      }
}
 

public class TesteConsole {
      static String nome;

      /**
       * @param args
       */
      public static void main(String[] args) {
            Console csl = System.console();
            char[]pw;
            pw = csl.readPassword("%s","pw: ");
            for (char ch : pw) {
                  csl.format("%c", ch);
            }
            csl.format("\n");
            Utils u = new Utils();
            while(true){
                  nome = csl.readLine("%s","entrada?: ");
                  csl.format("saída: %s \n", u.fazerAlgo(nome));
            }
      }
}

Na implementação do método main(), chamamos System.console() no sentido de conseguirmos a referência do console. Essa referência é armazenada na variável cls.

Em seguida, declaramos um array de chars e o populamos com o retorno do método cls.readPassword(“%s”,”pw:”). É importantíssimo que, ao executar o programa, você note que a String pw é exibida e existe uma pausa para que se digite a senha.

Continuando, vamos ao método readLine(). Este método captura a entrada do usuário a partir do teclado e retorna uma String.

Serialização

A serialização incide em gravar um arquivo que possui objetos achatados (serializados). A seguir, faça com q

Utilizando Arquivos e Diretórios

Uma tema que normalmente gera dúvida é o fato de que um objeto do tipo File é usado para representar ou um diretório ou um arquivo.

File file = new File(“caminhoDoFile”);

Existem dois modos de criar um arquivo:

1.    Criar uma Stream ou um Writer. Mais especificamente, criar um PrintWriter, um FileWriter, ou um FileOutputStream.

2.    Chamar o método createNewFile() a partir de um objeto File.

file.createNewFile();

Veja um exemplo completo a seguir:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class Principal {
      /**
       * @param args
       */
      public static void main(String[] args) {
            try{
                  PrintWriter pw = new PrintWriter("uuuu");
                  FileWriter fw = new FileWriter("vvvv");
                  FileReader fr = new FileReader("xxxx");
                  FileInputStream fi = new FileInputStream("yyyy");
                  FileOutputStream fo = new FileOutputStream("zzzz");
            }catch (IOException e) {
            }
      }
}

Do mesmo modo como na criação de um arquivo, criar um diretório é um procedimento de 2 etapas; primeiro, criamos um objeto Directory (File) e logo após criamos o diretório real através do método mkdir().

File dir = new File(“caminhoDiretorio”);

dir.mkdir();

No momento que tivermos um diretório, podemos colocar arquivos.

File arquivo = new File(dir, “arquivo.txt”);

Combinação de Classes E/S

O pacote java.io possui em torno de 50 classes, 15 exceções e 10 interfaces. Cada classe desse pacote tem uma finalidade bem específica. Esse é a verdadeira denotação da alta coesão.

package devmedia;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Executavel {
      /**
       * @param args
       */
      public static void main(String[] args) {
            char []array = new char[100];
            try{
                  FileWriter fw = new FileWriter("bbbbbb.txt");
                  fw.write("Linguagem\nJava");
                  fw.flush();
                  fw.close();
                 
                  FileReader fr = new FileReader("bbbbbb.txt");
                  fr.read(array);
                  for (char ch : array) {
                        System.out.println(ch);
                  }
                  fr.close();
            }catch (IOException e) {
            }

      }
}

Um modo interessante de estudo é verificar as várias combinações possíveis.

package devmedia;
public class StringTeste {
      /**
       * @param args
       */
      public static void main(String[] args) {
            String j = "abc";
            System.out.println(j.hashCode());
            j=j.concat("def");
            System.out.println(j);
            System.out.println(j.hashCode());
            System.out.println();
           
            StringBuffer sb = new StringBuffer("abc");
            System.out.println(sb.hashCode());
            sb.append("def");
            System.out.println("sb: "+sb);
            System.out.println(sb.hashCode());
      }
}

Uma String, antes de tudo, é um objeto da classe String. Os literais String (guardados na memória como objetos String) são escritos como um conjunto de caracteres entre aspas duplas.

O Java aborda todos os literais String com o mesmo conteúdo de um único objeto String que tem diversas referências a ele. Isso conserva memória.

Para o Java, cada caractere da String é um caractere Unicode de 16 bits.

Como provavelmente você já esteja ciente, a classe String possui muitos construtores, então podemos utilizar um modo mais eficaz para criar novas referências.

String str = new String(“xyz”);

Já que você utilizará Strings constantemente, poderá também fazer da seguinte forma:

String str = “xyz”;

Avalie a lista de vários construtores de String no próximo exemplo.

public class Construtores {

      /**
       * @param args
       */
      public static void main(String[] args) {
            char charArr[]={'f','e','l','i','z'};
            byte byteArray[]={'a','b','W','&',(byte)'¨'};
            StringBuffer buffer;
            String a,a1,a2,a3,a4,a5,a6,a7,output;
            s=new String("Olá");
            buffer = new StringBuffer("Java Devmedia");
            s1= new String();
            s2=new String(s);
            s3=new String(charArr);
            s4=new String(charArr,2,3);
            s5=new String(byteArr,0,1);
            s6=new String(byteArr);
            s7=new String(buffer);
            output = a1+" "+a2+" "+a3+" "+a4+" "+a5+" "+a6+" "+a7;
            System.out.println(output);
      }
}

O que distingue objetos String dos outros é a inalterabilidade. Uma vez dado um valor a uma String, esse valor jamais poderá ser modificado. Mesmo o objeto String não possa mais ser mudado, sua variável de referência poderá.

A JVM não pode alterar nessa String, sendo assim cria um novo objeto String e dá a ele o novo valor, em caso de adição de caracteres para o mesmo objeto em questão. Imagine quantos novos objetos são criados. Dessa totalidade, existe algum já selecionado para a coleta de lixo? Ou seja, objetos inatingíveis?

public class StringTeste {
      /**
       * @param args
       */
      public static void main(String[] args) {
            String s = "abcdef";//1 String
            System.out.println(s.hashCode());
            s=s+"fghij";//Outro objeto String
            System.out.println(s.hashCode());
            s=s.concat("klmno");//Outro objeto
            System.out.println(s.hashCode());
      }
}

E se não tivéssemos a sorte ou a visão de fazer uma segunda de referência para a String “abcdef” antes de chamarmos s = s.concat(“ coisas a mais?”)? Nessa situação, a String original não modificada como “abcdef” ainda permaneceria na memória, mas seria considerada perdida.

Concluiremos mostrando o tipo de questionamento capcioso sobre String que podemos nos deparar na prova da certificação. Não se precipite e use um papel para raciocinar. Orientação: tente manter um controle de quantos objetos e variáveis de referência permanecem e quais se referem a quê.

String x1 = "primavera";
String x2 = x1+" verão";//s2 é uma nova String que aponta para primavera verão
x1.concat("outono");//referência criada e perdida, s1 não muda!
x2.concat(x1);//referência criada e perdida, 

Com intuito de disponibilizarmos um tutorial minucioso de instalação da plataforma Android, foi desenvolvido esse artigo com grande participação do programador Francisco Robson da Silva Castro, que atua na IVIA-CE. Onde o grande foco é auxiliar desenvolvedores iniciantes nos primeiros passos de configuração do ambiente de desenvolvimento.

1 – Baixando e instalando o ANDROID SDK e/ou JDK

1.1. Baixar Android SDK em: http://developer.android.com/sdk/index.html e escolher a versão de instalação recomendada para o Windows.

1.2. Após a conclusão do Download do Android SDK, clique duplo sobre o ícone de instalação do mesmo. Irá aparecer a seguinte janela.

1.3. Clique em NEXT. Depois deste passo, poderá surgir uma tela pedindo para instalar o Java JDK compatível com a versão do Android SDK que estamos utilizando. Clique no botão VISIT JAV.ORACLE.COM. e irá abrir a no browser a página de Download do JDK. Ou acessar a url: http://www.oracle.com/technetwork/java/javase/downloads/index.html

Obs: Caso não apareça a tela abaixo, ir para o passo 2.

1.4. Selecione o JDK para download. Optei por baixar a versão Java EE.

1.5. Depois de selecione a Plataforma e a Língua, marque o checkbox para aceitar os Termos de Licença e click em CONTINUE.

1.6. Efetue o download e instale o JDK.

1.7. Instalando JDK

1.7.1. Inician

Mini-teste

1. Com o seguinte código:

try{
     int a[]= new int[2];
     a[3]=18;
}

Qual(s) opção(s) poderia ser utilizada para criar um bloco try/catch adequado?

a)    IndexOutOfBoundsException

b)    Throwable

c)    Exception

d)    ClassCastException

e)    NullPointerException

f)     NumbertFormatException

g)    IOException

h)    IllegalArgumentException

2. Dado:

static{
     int y[] = new int[1];
     y[2] =7;
}

Qual opção poderia ser utilizada para capturar a exceção lançada? (Escolha todas as corretas)

a)    ExceptionInInitialiazerError

b)    ClassCastException

c)    IndexOutOfBoundsException

d)    Throwable

e)    Exception

f)     NumberFormatException

g)    Error

h)    IllegalArgumentException

3. Analise o seguinte código:

public class Main{
     public static void main(String args[]){
          Object a = new Integer(2);
          System.out.println((String)a);
     }
}

Qual exceção será lançada quando o programa for executado?

a)    Nenhuma

b)    IndexOutOfBoundsException

c)    Throwable

d)    Exception

e)   

Assertivas

Avalie o seguinte exemplo.

private void doSomething(int num){

            if(num>=0){

                  //fazer algo

            }else{

                  System.out.println("Número negativo: "+num);

            }

      }

Vamos reescrever o doSomething() do exemplo acima.

package br.com.devmedia;

public class AssertExemplo {

      private static void doSomething(int num){

            assert(num>=0);

Definindo Exception(s)

Qualquer exceção é a instância de uma classe que tem a classe Throwable em sua hierarquia de herança. Ou seja, toda exceção é uma subclasse de java.lang.Throwable.

No instante em que uma exceção é lançada, o objeto de um subtipo de Throwable específico é instanciado e incluído no manipulador de exceções como um argumento para cláusula catch. Uma cláusula catch real tem o formato seguinte:

try{

            //código

} catch (ArrayIndexOutOfBoundsException e){

            e.printStackTarace();

}

Hierarquia de Exceções

As classes de exceções são subclasses de Throwable.

Existem dois subtipos que derivam de Throwable: Error e Exception. As classes que derivam de Error representam, situações excepcionais, que não são causadas por erros na programação e indicam algo que não ocorre normalmente na execução, como, por exemplo, a JVM ficar sem espaço na memória.

Manipulando uma hierarquia inteira de classes de exceções

Se a classe de execução que for especificada na cláusula catch não possui subclasses, então apenas a classe especificada será capturada. Porém, se a classe especificada na cláusula catch tiver subclasses, qualquer objeto de exceção com subclasses da classe especificada também será capturado.

Avalie o exemplo abaixo.

package br.com.devmedia;

public class X {

      static void metodoX(){

            String s = "Devmedia";

            s.charAt(50);

      }

      static void metodoY(){

            float f[]= new float[]{1.4F,4.5F};

            f[7]=8.3F;

      }

      /**

       * @param args

       */

      public static void main(String[] args) {

            try{

                  metodoX();

            }catch (StringIndexOutOfBoundsException s) {

                  System.out.println("StringIndexOutOfBoundsException");

            }

            try{

                  metodoY();

            }catch (ArrayIndexOutOfBoundsException e) {

                  System.out.println("ArrayIndexOutOfBoundsException");

            }

      }

}

Console:

StringIndexOutOfBoundsException

ArrayIndexOutOfBoundsException

Os manipuladores de exceção que capturarem diversas exceções de uma única vez possivelmente reproduzirão a confiabilidade do seu programa, uma vez que é bem possível que capturem uma exceção que não saibam tratar.

Os manipuladores de exceções mais específicos devem ser inseridos acima dos de exceções mais genéricas.

API e declarações de exceções

Do mesmo modo que um método precisa apontar que tipo e quantos argumentos aceitará, e o que será retornado, as exceções que um método pode lançar devem ser declaradas, a não ser que sejam subclasses de RuntimeException.

Apenas porque o método declara não quer dizer de fato que ele lançará tais exceções.

As exceções que não pertencerem a RuntimeException são consideradas verificadas (checked) porque o compilador fará uma checagem para ter plena certeza de que você sabe que algo inadequado pode ocorrer em determinado ponto.

Analise o código.

package br.com.devmedia;

import java.sql.SQLException;

public class Teste {

      static void conect ()throws SQLException{}

      static void conectCatch(){

            try{

                  conect();

            }

Capturando uma Exception com try e catch

Fique preparado para diversas perguntas no exame que incluam o controle de fluxo como parte do seu código, até mesmo aquelas que não estiverem ali analisando especificamente seu conhecimento sobre o assunto.

A especificação de Java estabelece que “uma exceção será lançada quando restrições semânticas forem violadas”, o que implica que exceção é lançada em situações que são não possíveis ou em violações sérias do comportamento admissível do sistema.

Então, precisamos de um modo de informar a JVM que código efetuar quando determinada exceção acontecer. Para fazer isso, usam-se as palavras-chave try e catch.

package br.com.devmedia;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

public class ExceptionTratamento {

      /**

       * @param args

       */

      public static void main(String[] args) {

            try{

                  BufferedReader buffer = new BufferedReader(new FileReader("teste.txt"));

            }catch (IOException e) {

                  System.out.println("Arquivo não encontrado "+ "teste.txt");

            }

      }

}

Um dos grandes benefícios da utilização da manipulação de exceções é que o código de manipulação de alguma exceção específica, que possa acontecer na região controlada, precisa ser escrito apenas uma única vez.

Bloco (finally)

O bloco finally vai definir o código que sempre será executado em algum local, após do bloco try, se uma exceção for ou não lançada.

Mesmo se acontecer uma instrução return no bloco try, o bloco finally será executado depois dessa instrução. Esse é o ponto ideal para fechar os arquivos, executar qualquer outra rotina de limpeza que seu código necessitar ou liberar os soquetes de rede.

Iremos avaliar o exemplo abaixo.

package br.com.devmedia;

public class X {

      static X x1;

      static X x2;

      static int divisao(int a, int b){

            return a/b;

      }

      /**

       * @param args

       */

      public static

5. Dado:

public class Main {

      /**

       * @param args

       */

      public static void main(String[] args) {

            for(int i = 0; i<3|(i%2)==0;System.out.print("BLA"), i++){

                  System.out.print(" "+i+" ");

            }

      }

}

O que será impresso?

a. BLA 0 BLA 1 BLA 2

b. 0 BLA 1 BLA 2 BLA

c. 0 BLA 1 BLA 2 BLA 3 BLA

d. 0 1 2 BLA BLA BLA

e. 0 1 2 BLA 3 BLA

f. esse código não compila

g. é lançada uma Exception

6. Dado o seguinte código:

public class SwitchTesteEnum {

      enum Naipe{PAUS,COPAS,ESPADAS,OUROS}

      /**

       * @param args

       */

      public static void main(String[] args) {

            String a = "Java ";

            switch (Naipe.COPAS) {

            case PAUS: a+="PAUS ";

            default: a+="não será impresso ";

            case COPAS: a+="copas ";

            break;

            case ESPADAS: a+=" espadilha ";

            break;

            case OUROS: a+="ouros ";

            }

            System.out.println(a);

      }

}

Qual será a saída?

a. copas

b. Java copas espadilha ouros

c. Java copas

d. copas espadilha ouros

e. copas Java

f. erro de compilação

g. é lançada uma exceção

7. Dado a classe:

public class LoopRotulado {

      /**

       * @param args

       */

      public static void main(String[] args) {

            System.out.print(true^true|false);

            System.out.print(true^true&true);

            System.out.print(true|true&false);

            System.out.print(true|true&&false);

      }

}

Qual é a saída no console?

a. truefalsetruefalse

b. falsefalsetruefalse

c. falsefalsefalsefalse

d. truetruetruetrue

e. falsetruefalsetruefalse

8. Dado:

public class X {

      /**

       * @param args

       */

      public static void main(String[] args) {

            int a=9,y=6;

            for(int z=0;z<6;z++,y--){

                  a--;

                  label:

                  if(a>3){

                        System.out.print(a+" ");

                        --a;

                        break label;

                  }

                  a--;

            }

      }

}

Qual é o resultado?

a. 8 7 6

b. 8 5

c. 8

d. 7

e. é lançada uma exceção

f. erro de compilação

9. Dado:

public class SwitchTeste {

      final static int x2=7;

      final static Integer y4=8;

      /**

       * @param args

       */

      public static void main(String[] args) {

            Integer x1=5;

            String s="a";

            if(x1<9)s+="b";

            switch(x1){

            case 5: s+="c";

            case x2: s+="d";

            case y4: s+="e";

            }

      }

}

Qual é o resultado?

a. abc

b. abcde

c. a compilação falha devido apenas a 1 erro, relativo a switch(x1)

d. a compilação falha devido a erros em várias linhas.

e. a compilação falha devido apenas a 1 erro, relativo a case y4: s+=”e”;

GABARITO COMENTADO

5. Resposta B

A sintaxe mostrada é válida. Em conjunto com a condição de incremento/decremento, qualquer outra instrução pode ser colocada. Pensando-se em termos bem amplos, o problema inteiro poderia ser resolvido em uma declaração de loop for. Porém, isso é por demais confuso. Esse loop será executado 3 vezes. O valor de i aparece na frente, sendo sucedido pela String.

6. Resposta C

A declaração de enum pode estar fora ou dentro da classe. O modo de invocação é a mesmo. Nesse caso, existe coincidência com o case copas e a String produzida será o resultado da concatenação entre Java e copas.

7. Resposta B

Note atentamente a tabela de precedência de operadores lógicos. É importante que você memorize esta tabela para a prova.

Mini-teste

1. Dado:

public class TesteIgualdade {

      /**

       * @param args

       */

      public static void main(String[] args) {

            float a1 = 1.4F;

            float[][]a2={{33.0f},{0.8f,1.4f},{1.7f,1.8f}};

            float[] a3={1,8f};

            Long y = 33L;

            //insira código aqui

            System.out.println("true");

      }

}

Além dos cinco fragmentos de código:

            if(a3==a2[2])

if(a1==a2[2][1])

            if(y==a2[0][0])          

            if(a1==a2[1,1])

            if(a1==a2)

Qual opção é correta?

a. 1 deles compilará e apenas 1 será true.

b. 2 deles compilarão e apenas 1 será true.

c. 2 deles compilarão e 2 serão true.

d. 3 deles compilarão e exatamente 2 serão true.

e. 3 deles compilarão e apenas 1 será true.

f. 3 deles compilarão exatamente 3 serão true.

2. Analise o código abaixo:

public class Executavel {

      /**

       * @param args

       */

      public static void main(String[] args) {

            Long a=42L;

            Long b=44L;

            System.

Expressões válidas para switch e case

A expressão switch deve analisar um char, byte, int, short ou enum. Isso quer dizer, que senão estiver usando um enum, apenas variáveis que puderem ser automaticamente promovidos, ou seja, implicitamente convertidos a um tipo int, serão permitidos.

Também, a instrução switch pode verificar apenas a igualdade. Ou seja, os outros operadores relacionais, como maior que (>), são considerados não-utilizáveis em uma instrução case.

Para o exame, procure por alguma violação nas regras de argumentos de switch e case. É possível encontrar exemplos inválidos, como os 2 abaixo.

//exemplo 1

switch(x){//faltam os dois pontos do case e o case não pode estar entre chaves

            case 0{

                        g=9;

            }

}

//exemplo2

switch(y){//omite a palavar-chave case

2:{ }

3:{ }

}

Loops e iteradores

As variantes de um loop proporcionam que a execução de um bloco de código seja repetida, enquanto uma determinada condição for verdadeira ou durante uma quantidade determinada de iterações.

Não se esqueça de verificar a utilização do ponto e vírgula ao final da expressão while. Como nos testes if, procure loops while com uma expressão que não resulte em booleano. Verifique alguns exemplos.

int a=1;

while(a){ }//Não compila, pois a não é booleano

while(a=8){ }//Não compila, pois a é resolvido como 8(resultado de atribuição)

while(a==8){ }//Válido teste de igualdade

while(true){ }//Válido

package br.devmedia;

public class Demo {

      /**

       * @param args

       */

      public static void main(String[] args) {

            int count = 2;

            while(count<12){

                  System.out.println("Count is: "+count);

                  count++;

            }

      }

}

class Demo2{

      public static void main(String args[]){

            int count = 2;

            do{

                  System.out.println("Count is: "+count);

                  count++;

            }while(count<=12);

      }

}

O loop for será especificamente útil para o controle de fluxo quando se souber quantas vezes terá que iterar. Sua declaração tem 3 partes: declaração/inicialização, expressão booleana e expressão de iteração. Cada uma é separada por ponto-e-vírgula. Todas essas partes são opcionais.

Opções de saídas forçadas incluem um return, um break, uma exceção ou uma instrução System.exit(). Todas essas opções fazem com que o loop seja encerrado bruscamente, sem executar a expressão de iteração. Ao se deparar com um break, a execução saltará imediatamente para próxima instrução após o loop for.

Ao se deparar com um return, a execução retornará imediatamente ao método chamador. Por último, ao encontrar um System.exit(), a execução do programa será totalmente interrompida e a JVM será finalizada.

O exemplo abaixo é perfeitamente válido, porém não é uma boa prática.

for(;;){

                  System.out.println("Loop Infinito");

            }

Operador condicional

Ao analisar expressões booleanas de modo parecido à instrução if, exceto por: em vez de executar um bloco de código se o resultado do teste for true, ele atribui um valor a uma variável. O operador condicional é um operador ternário.

Essa estrutura é exemplificada abaixo:

package br.devmedia;

public class Condicional {

      public static void main(String args[]){

            System.out.println(9==9?true:false);

            System.out.println(9==9?"Java":"Devmedia");

            System.out.println(4==9?"Java":"Devmedia");

            System.out.println(4==9?"Java":(1==1?true:false));

      }

}

Console:

true

Java

Devmedia

true

Operadores lógicos

Há apenas 6 operadores lógicos que você precisa saber para o exame (&, |, ^, &&, || e !). Três destes (&, | e ^) podem ser utilizados como operadores bitwise (bit a bit).

Esses operadores comparam dois literais bit a bit e retornam uma variável cujos bits foram definidos baseados em:

| -> ou um ou outro ligado

^ -> exatamente um ligado

& -> dois bits ligados

Instruções if e switch

As instruções if e loops for, são comuns em quase todas das linguagens de programação.

As instruções switch e if são os tipos de controle de decisão que permitirão ao seu programa agir de modo diferente em uma bifurcação de caminho, dependendo, obviamente, do resultado de um teste lógico.

Expressões válidas para instruções if

As instruções if podem avaliar somente valores booleanos. Note como os parênteses são capazes de subverter a ordem de precedência. O último if é o que, realmente, ilustra a precedência.

package br.devmedia;

public class Confuse {

      public static void main(String args []){

            int y =6, x=3;

            if(((x>4)&&(y<3))|true){

                  System.out.println("Primeiro "+true);

            }

            if(((x>4)&&(y<3))|false){

                  System.out.println("Segundo "+true);

            }