Questões de Concurso
Sobre java em programação
Foram encontradas 2.693 questões
( ) Objetos String não podem ter seu conteúdo alterado depois de criado.
( ) Java é uma linguagem de múltiplas threads.
( ) A classe Formatter contém o método printf, que permite gerar a saída de dados formatados na tela ou em um arquivo.
O Java CAPS oferece diversas potencialidades, EXCETO
public class Questao {
public static void main(String [ ] args) {
try {
op (0) ;
} catch (IllegalArgumentException e) {
System.out.print ("X") ;
} catch (Exception e) {
System.out.print ("Y") ;
} finally {
System.out.print ("Z") ;
}
}
private static void op(int v) throws IllegalArgumentException {
if (v == 0)
throw new IllegalArgumentException ("U") ;
}
}
Como resultado da execução desse programa, é impressa a cadeia de caracteres
Considere o exemplo de um código Java 6 a seguir.
public class Questao {
public static void main(String [ ] args) {
Integer a,b,c,d,e ;
int f ;
char r1,r2,r3,r4,r5 ;
String s ;
a=1; b=1; c = a ;
d= b; f=1; e = f.;
r 1= ( a.equals(b)? 's' : 'n' ) ;
r 2= ( a.equals(c)? 's' : 'n' ) ;
r 3= ( a==d? 's' : 'n' ) ;
r 4= ( a==e? 's' : 'n' ) ;
r 5= ( a.equals(f)? 's' : 'n' ) ;
s = " "+r1+r2+r3+r4+r5 ;
System.out.println(s) ;
}
}
Executando-se esse código, em que é possível testar como o comportamento exemplificado foi implementado para a classe Integer e o tipo int, a resposta impressa será
public class TestaArgs {
public static void main(String [ ] args) {
System.out.println(args [5] ) ;
}
}
Considere o seguinte comando:
java –hotspot TestaArgs um dois três quatro cinco seis sete
O que será impresso pelo programa ao executar esse comando?
package teste;
public class Teste {
public static void main(String[] args) {
int i = 0;
int[] vet = {2,2};
for (;i<=1;i++){
vet[i] = i++;
System.out.println(“vet” + i + “=” + vet[i]);
}
}
}
O que será exibido no console quando esse programa for executado?
A característica essencial das linguagens orientadas a objetos é de que elas incluem facilidades para permitir a
class ContaBancaria {
protected double saldo;
public Conta(double SaldoInicial) // constructor
{
saldo = SaldoInicial;
}
public void deposito(double valor)
{
saldo = saldo + valor;
}
public void retirada(double valor)
{
saldo = saldo - valor;
}
} // fim da classe ContaBancaria
public class ContaBancariaExt extends ContaBancaria {
public void display()
{
System.out.println(“Saldo = ” + saldo);
}
} // fim da classe ContaBancariaExt
Um programa que utilize a classe ContaBancariaExt e crie uma instância (objeto) dessa classe:
class ArraySort
{
private double [] a;
private int nElems;
// outras funcoes omitidas
// …
public void Sort()
{
int in, out;
for (out = nElems-1; out > 1; out--)
for (in = 0; in < out; in++)
if (a[in] > a[in+1])
swap(in, in+1);
} // fim da Sort
private void swap (int x, int y)
{
double temp = a[x];
a[x] = a[y];
a[y] = temp;
}
} // fim da classe ArraySort
O código apresenta a implentação de uma classe ArraySort, que contém um método denominado Sort, cuja finalidade é implementar a
class S {
private int Tamanho;
private int[] sArray;
private int top;
//--------------------------------------------------------------
public S(int s) // constructor
{
Tamanho = s;
sArray = new long[Tamanho]; // create array
top = -1;
}
//--------------------------------------------------------------
public void coloca(int j)
{
sArray[++top] = j;
}
//--------------------------------------------------------------
public long tira()
{
return sArray[top--];
}
//--------------------------------------------------------------
} // end class S
Esse trecho implementa uma classe que corresponde a uma
public class PrincipalA { public static void main(String[] args) { int cont; cont = 12; do { cont++; System.out.println(cont); } while (cont <= 11); System.out.println(cont); } }
public class PrincipalB { public static void main(String[] args) { int cont; cont = 12; while (cont <= 11) { cont++; System.out.println(cont); } System.out.println(cont); } }
Os valores que serão exibidos após a compilação e execução de cada classe são:
import javax.swing.JOptionPane;
public class Principal {
public static void main(String[ ] args) {
double a, b, c, r;
a = Double.parseDouble (JOptionPane.showInputDialog
("Digite o valor de a:"));
b = Double.parseDouble
(JOptionPane.showInputDialog ("Digite o valor de b:"));
c = Double.parseDouble (JOptionPane.showInputDialog
("Digite o valor de c:"));
if (a < b && a < c) {
r = (b + c) / 2;
} else if (b < c) {
r = (a + c) / 2;
} else {
r = (a + b) / 2;
}
System.out.print(r);
}
}
É possível concluir que:
O escopo (ou visibilidade) de uma variável de instância em JAVA pode ser controlado através do uso de modificadores de variáveis. Sobre os modificadores de variáveis de instância em JAVA, é correto afirmar que
1. public permite que qualquer método possa acessar as variáveis de instância.
2. private permite que apenas métodos do mesmo pacote ou subclasse possam acessar as variáveis de instância.
3. protected permite que apenas métodos da mesma classe (excluindo métodos de uma subclasse) possam acessar as variáveis de instância.
Quais propostas estão corretas?
I. Esta linguagem de programação combina características de linguagens tipadas estatica e dinamicamente. Como em uma linguagem de tipagem estática, cada variável e elemento de programação em Java têm um tipo que é conhecido a tempo de compilação, de modo que, a tempo de execução, não há necessidade, normalmente, de se verificar a validade de atribuições entre tipos enquanto o código está sendo executado. Ao contrário das linguagens tradicionais C ou C++, Java também mantém informações a tempo de execução sobre objetos e usa isso para permitir comportamento verdadeiramente dinâmico. O código Java pode carregar novos tipos em tempo de execução e usá- los de forma totalmente orientada a objetos, permitindo polimorfismo.
II. Variáveis declaradas como membros de uma classe são definidas com valores default, se não forem inicializadas explicitamente. Nesse caso, o default para os tipos numéricos é zero; para caracteres, é o caractere nulo (\0); e, para as variáveis booleanas, é o valor falso.
III. Objetos são alocados com o operador NEW usando um construtor de objeto. Um construtor é um método especial com o mesmo nome de sua classe e com nenhum tipo de retorno. É chamado quando uma nova instância da classe é criada, o que dá à classe uma oportunidade para definir o objeto para uso. Construtores, como ocorre com outros métodos, podem aceitar argumentos e podem ser sobrecarregados, embora não sejam herdados como os outros métodos.
Quais estão corretas?