Postado pelo autor da postagem original: 17/06/2008 15:26:20
lJBS
1. Liste 10 vantagens da linguagem JAVA
a: Gratuito, código aberto, plataforma cruzada (independência de plataforma), fácil de usar, funções completas, orientado a objetos, robusto, multithread, estrutura neutra, plataforma madura para aplicativos corporativos, aplicativos sem fio
2. Liste 10 termos de programação orientada a objetos em JAVA
a: pacote, classe, interface, objeto, atributo, método, construtor, herança, encapsulamento, polimorfismo, abstração, paradigma
3. Liste 6 pacotes comumente usados em JAVA
Java.lang;java.util;java.io;java.sql;java.awt;java.net;java.applet;javax.swing
4. Quais são as funções e características dos identificadores em JAVA Função: Os identificadores são utilizados para nomear variáveis, classes e métodos: Além de começarem com letras, sublinhados "_" e "$", podem ser seguidos por caracteres. letras, caracteres de sublinhado "_" e "$" ou números
Java diferencia maiúsculas de minúsculas e os identificadores não são exceção
5.Quais são as características das palavras-chave em JAVA? Liste pelo menos 20 palavras-chave?
Algumas palavras em Java que recebem significados específicos e são usadas para fins especiais são chamadas de palavras-chave.
Todas as palavras-chave Java estão em letras minúsculas, TURE, FALSE, NULL, etc. não são palavras-chave Java;
goto e const, embora nunca usados, são reservados como palavras-chave Java;
Há um total de 51 palavras-chave Java em •
abstract assert boolean break byte continue
case catch char classe const duplo
padrão do estende else float final
por muito tempo se implementa importação
nova instância nula nativa da interface int
pacote privado protegido público retorno curto
Super switch static strictfp sincronizou isso
enquanto void throw lança tentativa transitória
volátil
6.Como os tipos de dados são classificados em JAVA?
Podem ser divididos em tipos de dados simples e tipos de dados de referência:
Tipos de dados simples: tipo numérico (byte, short, int, long, float double), tipo de caractere (char), tipo booleano (boolean);
Tipos de dados de referência: classe, interface, array.
7. Classificação e exemplos de operadores em JAVA
•
• Operadores aritméticos: +, ―, *, /, %, ++, ――
• Operadores relacionais: >, <, >=, <=, ==, !=
• Operadores lógicos booleanos: !, &, |, ^, &&, ||
• Operadores de bits: &, |, ^, ~, >>, < <, >>>
• Operador de atribuição: = Operador de atribuição estendido: +=, ―=, *=, /=
• Operador de concatenação de strings: +
• Operador de forma: ()
8.A função e uso de super e estas palavras-chave
• Use super em uma classe Java para se referir a componentes da classe pai
– Pode ser usado para acessar atributos superdefinidos na classe pai
– Pode ser usado para chamar o método membro superdefinido na classe pai
– Pode ser usado para chamar o construtor da superclasse super no construtor da subclasse
– A rastreabilidade não está limitada à classe pai direta super
Para resolver o problema de conflito de nomenclatura e incerteza de variáveis, a palavra-chave “this” é introduzida para representar o objeto atual do método no qual está localizado. Java
– O construtor refere-se ao novo objeto criado pelo construtor
– O método refere-se ao objeto que chama o método
•
– Faça referência às variáveis de instância e métodos da classe no método ou construtor da própria classe
– Passa o objeto atual como parâmetro para outros métodos ou construtores
– Usado para chamar outros construtores sobrecarregados
9. O que é uma expressão em JAVA? O que isso faz?
• Uma expressão é uma combinação de operadores e operandos e é um componente chave de qualquer linguagem de programação
• As expressões permitem aos programadores realizar cálculos matemáticos, comparação de valores, operações lógicas e manipulação de objetos em Java.
•
–X
–X+10
– Y=x+10
–Arr[10]
– aluno.geNome()
10. Faça uma tabela listando todos os modificadores em JAVA e seu escopo de aplicação (eles podem modificar construtores, propriedades, blocos livres, etc.)
classe atributo método construtor bloco livre classe interna
público AAA S S
protegido YY Y Y
(Padrão) AAAAA
privado YY Y Y
final AAA S S
abstrato S Y S
estático S YY
11. Escreva um método para imprimir a tabuada usando um loop for
/**
*Um loop for imprime a tabuada
*/
publicvoid noveNineMultiTable()
{
for (int i = 1,j = 1; j <= 9; i++) {
System.out.print(i+"*"+j+"="+i*j+" ");
se(eu==j)
{
eu=0;
j++;
System.out.println();
}
}
}
12. Dado um objeto java.util.Date, como convertê-lo em uma string no formato "2007-3-22 20:23:22"
/**
*Converta uma data em uma string em formato fixo
*@paramdate
*@returnstr
*/
string pública dateToStr(data java.util.Date)
{
SimpleDateFormat sdf = new SimpleDateFormat("aaaa-MM-dd HH:mm:ss");
String str = sdf.format(data);
retornar string;
}
13. Escreva um método que possa determinar se qualquer número inteiro é primo.
/**
* Determine se algum número inteiro é primo
*@paramn
*@returnboolean
*/
publicboolean isPrimes(int n)
{
for (int i = 2; i <= Math.sqrt(n); i++) {
se(n%i==0)
{
retorno falso;
}
}
retornar verdadeiro;
}
14. Escreva um método que insira qualquer número inteiro e retorne seu fatorial
/**
* Obtenha o fatorial de qualquer número inteiro
*@paramn
*@returnn !
*/
publicint fatorial (int n)
{
//recursão
se(n==1)
{
retornar 1;
}
retornar n*fatorial(n-1);
//não recursivo
//int multi = 1;
//for (int i = 2; i <= n; i++) {
// multi*=i;
// }
//retorna multi;
}
15. Escreva um método que use pesquisa binária para determinar se existe algum número inteiro em qualquer matriz de inteiros. Se existir, retorne sua posição de índice na matriz. Se não existir, retorne -1.
/**
*Pesquisa binária pela posição de um inteiro específico na matriz de inteiros (recursiva)
*@paramdataset
*@paramdata
*@parambeginIndex
*@paramendIndex
*@returnindex
*/
publicint binarySearch(int[] conjunto de dados,int dados,int beginIndex,int endIndex)
{
int midIndex = (beginIndex+endIndex)/2;
if(dados <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex)return -1;
if(dados <conjunto de dados[midIndex])
{
retornar pesquisabinária(conjunto de dados,dados,beginIndex,midIndex-1);
}elseif(dados>conjunto de dados[midIndex])
{
retornar pesquisabinária(conjunto de dados,dados,midIndex+1,endIndex);
}outro
{
retornar índice médio;
}
}
/**
*Pesquisa binária pela posição de um inteiro específico na matriz de inteiros (não recursiva)
*@paramdataset
*@paramdata
*@returnindex
*/
publicint binarySearch(int[]conjunto de dados,int dados)
{
int índiceInício = 0;
int endIndex = conjunto de dados.comprimento - 1;
int índice médio = -1;
if(dados <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex)return -1;
while(beginIndex <= endIndex) {
midIndex = (beginIndex+endIndex)/2;
if(dados <conjunto de dados[midIndex]) {
endIndex = midIndex-1;
} elseif(dados>conjunto de dados[midIndex]) {
começarIndex = midIndex+1;
}outro
{
retornar índice médio;
}
}
retornar -1;
}
16. Um exemplo de um criador alimentando animais com alimentos reflete o pensamento orientado a objetos em JAVA e a utilidade das interfaces (classes abstratas)
pacote com.softeem.demo;
/**
*@autorleno
*Interface animal
*/
interface Animal
{
publicvoid comer(Comida alimentar);
}
/**
*@autorleno
*um tipo de animal: gato
*/
classe Gato implementa Animal
{
publicvoid comer (comida)
{
System.out.println("Gatinho come"+food.getName());
}
}
/**
*@autorleno
*um tipo de animal: cachorro
*/
classe Cachorro implementa Animal
{
publicvoid comer (comida)
{
System.out.println("Cachorro Mastigando"+food.getName());
}
}
/**
*@autorleno
* Aula abstrata de comida
*/
abstractclassFood
{
nome da string protegida;
public String getNome() {
nome de retorno;
}
publicvoid setNome(Nome da string) {
este.nome = nome;
}
}
/**
*@autorleno
*Um grupo alimentar: peixe
*/
classe Peixe estende Comida
{
peixe público (nome da string) {
este.nome = nome;
}
}
/**
*@autorleno
*Um grupo de alimentos: ossos
*/
classe Osso estende Comida
{
osso público (nome da string) {
este.nome = nome;
}
}
/**
*@autorleno
*Categoria de criador
*
*/
classFeeder
{
/**
*O criador alimenta um certo tipo de alimento com um certo tipo de animal
*@paramanimal
*@paramfood
*/
alimentação publicvoid (animal animal, comida alimentar)
{
animal.comer(comida);
}
}
/**
*@autorleno
*Criadores de teste alimentando animais com ração
*/
publicclass TestFeeder {
publicstaticvoid principal(String[] args) {
Alimentador alimentador=novo Alimentador();
Animal animal=novo Cachorro();
Comida comida=novo Osso("osso de carne");
feeder.feed(animal,food); //Dar ossos de carne ao cachorro
animal=novo Gato();
comida=novo Peixe("peixe");
feeder.feed(animal,comida); //Dar peixe ao gato
}
}
18. Crie uma classe de modo único e carregue o arquivo de propriedades apenas uma vez
pacote com.softeem.demo;
importar java.io.FileInputStream;
importar java.io.FileNotFoundException;
importar java.io.IOException;
importar java.io.InputStream;
importar java.util.Properties;
/**
*@autorleno
*Modo único, garantindo que o arquivo de propriedades de configuração seja carregado apenas uma vez durante toda a aplicação
*/
classe pública Singleton {
Instância Singleton privatestatic;
privatestaticfinal String CONFIG_FILE_PATH = "E:\config.properties";
configuração de propriedades privadas;
Singleton privado()
{
config = novas propriedades();
InputStream é;
tentar {
é = novo FileInputStream(CONFIG_FILE_PATH);
config.load(é);
é.close();
} catch (FileNotFoundException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
} catch (IOException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
publicstatic Singleton getInstance()
{
if(instância==nulo)
{
instância = novo Singleton();
}
instância de retorno;
}
Propriedades públicas getConfig() {
returnconfig;
}
publicvoid setConfig(configuração de propriedades) {
isto.config=config;
}
}
eu J2SE
19. Copie um diretório (arquivo) para o caminho especificado
/**
*Copie um diretório ou arquivo para o caminho especificado
*@paramsource
*@paramtarget
*/
cópia publicvoid (fonte do arquivo, destino do arquivo)
{
Arquivo tarpath = new Arquivo(target,source.getName());
if(fonte.isDirectory())
{
tarpath.mkdir();
Arquivo[] dir = source.listFiles();
for (int i = 0; i < dir.length; i++) {
copiar(dir[i],tarpath);
}
}outro
{
tentar {
InputStream é = new FileInputStream(fonte);
OutputStream os = novo FileOutputStream(tarpath);
byte[] buf = newbyte[1024];
int len=0;
while((len = is.read(buf))!=-1)
{
os.write(buf,0,len);
}
é.close();
os.close();
} catch (FileNotFoundException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
} catch (IOException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
}
20. Exemplo de problema de saque bancário usando multithreading em JAVA
pacotecom.softeem.demo;
/**
*@autorleno
*Tipo de conta
*Há um saldo por padrão e você pode sacar dinheiro
*/
classe Conta {
privatefloatbalance = 1000;
publicfloat getBalance() {
saldo de retorno;
}
publicvoid setBalance(saldo flutuante) {
este.saldo = saldo;
}
/**
*Os métodos de retirada precisam ser sincronizados
*@parammoney
*/
saques públicos sincronizados e vazios (dinheiro flutuante)
{
if(saldo>=dinheiro)
{
System.out.println("Pegado"+dinheiro+"Yuan!");
tentar {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
saldo-=dinheiro;
}
outro
{
System.out.println("Desculpe, saldo insuficiente!");
}
}
}
/**
*@autorleno
*cartão bancário
*/
class TestAccount1 estende Thread {
conta de conta privada;
public TestAccount1(Conta de conta) {
esta.conta = conta;
}
@Substituir
execução pública void() {
conta.retiradas(800);
System.out.println("O saldo é:"+account.getBalance()+"Yuan!");
}
}
/**
*@autorleno
* Caderneta
*/
class TestAccount2 estende Thread {
conta de conta privada;
public TestAccount2(conta conta) {
esta.conta = conta;
}
@Substituir
execução pública void() {
conta.retiradas(700);
System.out.println("O saldo é:"+account.getBalance()+"Yuan!");
}
}
Teste de classe pública
{
publicstaticvoid principal(String[] args) {
Conta conta = nova conta();
TestAccount1 testAccount1 = new TestAccount1(conta);
testAccount1.start();
TestAccount2 testAccount2 = new TestAccount2(conta);
testAccount2.start();
}
}
21. Use multi-threading em JAVA para exemplificar o problema de venda de passagens em estações de trem
pacote com.softeem.demo;
/**
*@autorleno
*Venda de ingressos
*/
classe SaleTicket implementa Runnable {
ingressos = 100;
execução pública void() {
enquanto (tíquetes > 0) {
oferta();
//Ou implemente assim
// sincronizado (isto) {
// if (tíquetes > 0) {
// System.out.println(Thread.currentThread().getName() + "Venda o primeiro"
// + (100 - ingressos + 1) + "ingressos");
// ingressos--;
// }
// }
}
}
publicsynchronizedvoid sale() {
if (tíquetes > 0) {
System.out.println(Thread.currentThread().getName() + "Vender primeiro"
+ (100 - ingressos + 1) + “ingressos”);
ingressos--;
}
}
}
publicclass TestSaleTicket {
publicstaticvoid principal(String[] args) {
SaleTicket st = new SaleTicket();
new Thread(st, "Janela No. 1").start();
new Thread(st, "Janela No. 2").start();
new Thread(st, "Janela No. 3").start();
new Thread(st, "Janela No. 4").start();
}
}
22. Exemplo de problemas de produtor e consumidor usando multithreading em JAVA
pacote com.softeem.demo;
classe Produtor implementa Runnable
{
pilha SyncStack privada;
produtor público (pilha SyncStack) {
esta.stack = pilha;
}
execução pública void() {
for (int i = 0; i < stack.getProducts().length; i++) {
String produto = "produto"+i;
pilha.push(produto);
System.out.println("Produzido: "+produto);
tentar
{
Thread.sleep(200);
}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
}
}
classe Consumidor implementa Executável
{
pilha SyncStack privada;
Consumidor público (pilha SyncStack) {
esta.stack = pilha;
}
execução pública void() {
for(int i=0;i <stack.getProducts().length;i++)
{
String produto =stack.pop();
System.out.println("Consumido: "+produto);
tentar
{
Thread.sleep(1000);
}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
}
}
classe SyncStack
{
private String[] produtos = new String[10];
índice privado;
publicsynchronizedvoid push (produto String)
{
if(índice==produto.comprimento())
{
tentar {
espere();
} catch (InterruptedException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
notificar();
produtos[índice]=produto;
índice++;
}
String pública sincronizada pop()
{
se(índice==0)
{
tentar {
espere();
} catch (InterruptedException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
notificar();
índice--;
String produto = produtos[índice];
devolver produto;
}
public String[] getProdutos() {
devolver produtos;
}
}
publicclass TestProducerConsumidor {
publicstaticvoid principal(String[] args) {
Pilha SyncStack=new SyncStack();
Produtor p=novo Produtor(pilha);
Consumidor c=novo Consumidor(pilha);
novo Thread(p).start();
novo Thread(c).start();
}
}
23. Programação para realizar a transmissão de objetos Student serializados (sno, sname) na rede
pacote com.softeem.demo;
importar java.io.IOException;
importar java.io.ObjectInputStream;
importar java.io.ObjectOutputStream;
importar java.io.Serializable;
importar java.net.ServerSocket;
importar java.net.Socket;
classe Aluno implementa Serializable {
privado interno sno;
nome da string privada;
public Student(int sno, String nome) {
isto.sno = sno;
this.sname = nome;
}
public int getSno() {
retornar nada;
}
public void setSno(int sno) {
isto.sno = sno;
}
public String getSnome() {
retornar nome;
}
public void setSname(String nome) {
this.sname = nome;
}
@Substituir
string pública paraString() {
return "Número do aluno:" + sno + ";Nome:" + sname;
}
}
class MeuCliente estende Thread {
@Substituir
execução nula pública() {
tentar {
Soquete s = new Soquete("localhost", 9999);
ObjectInputStream ois = new ObjectInputStream(s.getInputStream());
Aluno stu = (Aluno) ois.readObject();
System.out.println("O programa cliente recebe o objeto aluno transferido do programa servidor >> " + stu);
ois.close();
s.close();
} catch (IOException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
}
class MeuServidor estende Thread {
@Substituir
execução nula pública() {
tentar {
ServerSocket ss = novo ServerSocket(9999);
Soquete s = ss.accept();
Operações ObjectOutputStream = new ObjectOutputStream(s.getOutputStream());
Aluno stu = novo Aluno(1, "Zhao Benshan");
ops.writeObject(stu);
ops.close();
s.close();
ss.close();
} catch (IOException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
}
classe pública TestTransfer {
public static void main(String[] args) {
new MeuServidor().start();
new MeuCliente().start();
}
}
eu JDBC
24. Use o componente dom4j para analisar os seguintes arquivos de formato XML:
<?xml versão="1.0" codificação="UTF-8"?>
<gerador>
<nome da tabela="login" operação="1">
<column name="username" handle="0">aaa </column>
<column name="password" handle="0">123 </column>
</tabela>
<nome da tabela="login" operação="2">
<column name="id" handle="1">1 </column>
<column name="username" handle="0">bbb </column>
<column name="password" handle="0">444 </column>
</tabela>
<nome da tabela="login" operação="3">
<column name="id" handle="1">4 </column>
</tabela>
</gerador>
Regras: <tabela>operação 1 inserção de tabela, atualização de tabela 2, exclusão de tabela 3.
<coluna>a tabela handle 1 é usada como condição where, a tabela 0 é usada como campo de operação.
Requisito: Gere três instruções SQL de acordo com as regras! (Ou seja, crie um método para analisar o arquivo xml para gerar uma string contendo três instruções SQL)
/**
*Analisar o arquivo XML para gerar uma string contendo instruções SQL executáveis
*@paramxmlNomeArquivo
*@returnSQL
*/
public String parseXmltoSQL(String xmlFileName) {
StringBuffer sbsql = new StringBuffer();
Leitor SAXReader = new SAXReader();
tentar {
Documento documento = leitor.read(new Arquivo(xmlFileName));
Elemento elemento = document.getRootElement();
Iterador it = element.elementIterator("tabela");
enquanto (it.hasNext()) {
elemento = (Elemento) it.next();
//Coloca as operações na mesa
String oper = element.attributeValue("operação");
//Obtém o nome da tabela
String nometabela = element.attributeValue("nome");
if ("1".equals(oper)) {
sbsql.append("inserir em ").append(tableName);
Iterador it2 = element.elementIterator("coluna");
String nomeColuna1 = null;
String valorcoluna1 = null;
String nomeColuna2 = null;
String valorcoluna2 = null;
if (it2.hasNext()) {
elemento = (Elemento) it2.next();
nomecoluna1 = element.attributeValue("nome");
colunaValue1 = element.getText();
}
if (it2.hasNext()) {
elemento = (Elemento) it2.next();
nomecoluna2 = element.attributeValue("nome");
colunaValue2 = element.getText();
}
sbsql.append("("+columnName1+","+columnName2+")"+" valores('"+columnValue1+"','"+columnValue2+"')n");
} elseif ("2".equals(oper)) {
sbsql.append("atualização ").append(nomedatabela);
Iterador it2 = element.elementIterator("coluna");
String nomeColuna1 = null;
String valorcoluna1 = null;
String nomeColuna2 = null;
String valorcoluna2 = null;
String nomeColuna3 = null;
String valorcoluna3 = null;
if (it2.hasNext()) {
elemento = (Elemento) it2.next();
nomecoluna1 = element.attributeValue("nome");
colunaValue1 = element.getText();
}
if (it2.hasNext()) {
elemento = (Elemento) it2.next();
nomecoluna2 = element.attributeValue("nome");
colunaValue2 = element.getText();
}
if (it2.hasNext()) {
elemento = (Elemento) it2.next();
nomecoluna3 = element.attributeValue("nome");
colunaValue3 = element.getText();
}
sbsql.append(" set "+columnName2+"='"+columnValue2+"',"+columnName3+"='"+columnValue3+"' onde "+columnName1+"="+columnValue1+"n");
}elseif("3".equals(oper)) {
sbsql.append("excluir de ").append(tableName);
Iterador it2 = element.elementIterator("coluna");
String nomeColuna1 = null;
String valorcoluna1 = null;
if (it2.hasNext()) {
elemento = (Elemento) it2.next();
nomecoluna1 = element.attributeValue("nome");
colunaValue1 = element.getText();
}
sbsql.append(" where "+columnName1+"="+columnValue1);
}
}
} catch (DocumentException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
retornar sbsql.toString();
}
lJSP/SERVLET
25. Escreva os objetos integrados do JSP e explique suas funções
request:request representa o objeto HttpServletRequest. Ele contém informações sobre a solicitação do navegador e fornece vários métodos úteis para obter dados de cookies e cabeçalhos. response:response representa o objeto HttpServletResponse e fornece vários métodos para definir a resposta enviada de volta ao navegador (como cookies, informações de cabeçalho, etc.). O objeto out:out é uma instância de javax.jsp.JspWriter e fornece vários métodos que você pode usar para enviar a saída de volta ao navegador. pageContext: pageContext representa um objeto javax.servlet.jsp.PageContext. É uma API usada para facilitar o acesso a vários escopos de namespaces e objetos relacionados a servlets, e agrupa métodos de funções comuns relacionadas a servlets. session:session representa um objeto javax.servlet.http.HttpSession solicitado. A sessão pode armazenar informações de status do usuário. application:applicaton representa um objeto javax.servle.ServletContext. Isso ajuda a localizar informações sobre o mecanismo de servlet e o ambiente de servlet. config:config representa um objeto javax.servlet.ServletConfig. Este objeto é utilizado para acessar os parâmetros de inicialização da instância do servlet. page:page representa uma instância de servlet gerada a partir desta página.
exceção: O objeto de exceção é um objeto de exceção. Quando ocorre uma exceção durante a execução de uma página, este objeto é gerado. Se uma página JSP quiser usar este objeto, ela deverá definir isErrorPage como true, caso contrário não poderá ser compilada. Na verdade, é a contrapartida de java.lang.Throwable