Artigos Java Mini-Teste: Desmistificando a Certificação SCJP6 Parte IX - Parte 4

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?
    1. IndexOutOfBoundsException
    2. Throwable
    3. Exception
    4. ClassCastException
    5. NullPointerException
    6. NumbertFormatException
    7. IOException
    8. 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)
    1. ExceptionInInitialiazerError
    2. ClassCastException
    3. IndexOutOfBoundsException
    4. Throwable
    5. Exception
    6. NumberFormatException
    7. Error
    8. 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?
    1. Nenhuma
    2. IndexOutOfBoundsException
    3. Throwable
    4. Exception
    5. ClassCastException
  4. Observe o código abaixo: 
    
                try{int y = Integer.parseInt(“texto”);}
    Qual opção poderia ser utilzada para criar um bloco catch adequado? (Escolha todas as corretas)
    1. IllegalFormatException
    2. IndexOutOfBoundsException
    3. Throwable
    4. Exception
    5. NullPointerException
    6. NumberFormatException
    7. IOException
    8. ClassCastException
  5. Dado: 
    
                package devmedia;
                class Dad{

                int getInt(String x) throws Exception{return 22;}

                }

                class Son extends Dad{
                public static void main(String args[]){
                Dad d = new Son();
                System.out.println(d.getInt(“55”));
                }
                int getInt(String arg){
                return Integer.parseInt(arg);
                }
                }
    Além das 3 modificações possíveis:
    1. Declarar que main() lança uma Exception.
    2. Declarar que getInt() de Son lança uma Exception.
    3. Encapsular a chamada de getInt() em um bloco try/catch.

    1. A e B são obrigatórias.
    2. B e C são obrigatórias.
    3. Todas as 3 modificações são obrigatórias
    4. A sozinha é suficiente.
    5. B sozinha é suficiente.
    6. C sozinha é suficiente.
  6. Quais opções são verdadeiras?
    1. Não é apropriado usar assertivas para validar argumentos de linha de comando.
    2. É apropriado capturar e manipular erros de assertivas.
    3. É apropriado usar assertivas para validar argumentos de linha de comando.
    4. Não é apropriado usar assertivas que modifiquem o estado de um programa.
    5. É apropriado usar assertivas para validar argumentos para métodos com modificador public.

GABARITO COMENTADO

  1. Resposta A, B e C

    A exceção que será lançada no bloco try é uma instância de ArrayIndexOutOfBoundsException, portanto qualquer exceção que esteja acima dessa classe, na hierarquia, está correta.

  2. Resposta A, D e G

    Devido a exceção ser criada dentro de um bloco estático, trata-se de uma ExceptionInInitializerError. Desse modo, qualquer classe que esteja acima, na hierarquia de classes, poderia capturá-la em um bloco catch.

  3. Resposta E

    É impossível, em tempo de execução, converter a referência polimórfica a em uma String. Sendo assim, o programa compila, porém uma ClassCastException é lançada.

  4. Resposta A, C, D e F

    A exceção lançada será uma NumberFormatException. Veja a hierarquia:
    Object -> Throwable -> Exception -> RuntimeException -> IllegalArgumentException -> NumberFormatException

    Outro fato importante a ser notado é que se trata de uma exceção não-verificada. Desse modo, ela não precisaria ser tratada.

  5. Resposta D, E e F

    A alternativa D consiste em lançar a exceção em vez de tratá-la. A alternativa F consiste em tratar a exceção. Todas são corretas e resolvem o problema sozinhas.

  6. Resposta A e D

    Não é adequado utilizar assertivas para validar argumentos de linha de comando. É apropriado usar assertivas para gerar alertas quando você alcança um código que não deveria ser alcançado. Não é apropriado utilizar assertivas que alterem o estado de um programa. É apropriado usar assertivas para validar argumentos para métodos com modificador private. Não é apropriado capturar e manipular erros de assertivas.

Estamos próximos ao fim de nossa série, só falta mais duas partes e estaremos prontos para realizarmos nossa prova de certificação.

Até a próxima!

Leia todos artigos da série