11. Escribe un método para imprimir la tabla de multiplicar usando un bucle for.
/**
*Un bucle for imprime la tabla de multiplicar nueve-nueve
*/
publicvoid nineNineMultiTable()
{ for (int i = 1,j = 1; j <= 9; i++) { System.out.print(i+"*" +j+ "="+i*j+" "); if(i==j) { i=0; j++; System.out.println(); } } } 12. Dado un objeto java.util.Date, ¿cómo para convertir una cadena en el formato "2007-3-22 20:23:22" /** *Convertir una fecha en una cadena en un formato fijo *@paramdate *@returnstr */ public String dateToStr(java.util. Fecha fecha) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = sdf.format(date);
return str;
}
13. Escribe un método que pueda determinar si un número entero es primo
/**
*Determinar si algún número entero es primo
*@paramn
*@returnboolean
*/
publicboolean isPrimes(int n)
{ for (int i = 2; i <= Math.sqrt(n); i++) { if(n%i==0 ) { returnfalse; } } returntrue; } 14. Escribe un método que ingrese cualquier número entero y devuelva su factorial /** *Obtener el factorial de cualquier número entero *@paramn *@returnn! */
publicint factorial(int n)
{ //Recursivo if(n==1) { return 1; } return n*factorial(n-1); //No recursivo // int multi = 1; // for (int i = 2; i <= n; i++) { // multi*=i; // } // return multi; } 15. Escriba un método que utilice la búsqueda binaria para determinar si existe algún número entero en cualquier matriz de enteros. Si existe , Devuelve su posición de índice en la matriz, devuelve -1 si no existe /** *Búsqueda binaria de la posición de un entero específico en la matriz de enteros (recursiva) *@paramdataset *@paramdata *@parambeginIndex *@paramendIndex * @returnindex */ publicint binarioSearch(int[] conjunto de datos,int datos,int startIndex,int endIndex)
{ int midIndex = (beginIndex+endIndex)/2; if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex)return -1; if(data <dataset[midIndex]) { return binarioBuscar (conjunto de datos,datos,beginIndex,midIndex-1); }elseif(datos>conjunto de datos[midIndex]) { return binarySearch(dataset,data,midIndex+1,endIndex); }else { return midIndex; } } /** *Biary Encuentre la posición de un entero específico en una matriz de enteros (no recursiva) *@paramdataset *@paramdata *@returnindex */ publicint binarioSearch(int[] dataset,int data)
{ int startIndex = 0; int endIndex = conjunto de datos.length - 1; int midIndex = -1; if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex)return -1; while(beginIndex <= endIndex) { midIndex = (beginIndex+endIndex)/2; if(datos <conjunto de datos[midIndex]) { endIndex = midIndex-1; } elseif(datos>conjunto de datos[midIndex]) { comenzarIndex = midIndex+1; }else { return midIndex; } } return -1; } 16. Un ejemplo de un criador que alimenta a los animales refleja el pensamiento orientado a objetos en JAVA y la utilidad de las interfaces (clases abstractas)
paquete com.softeem.demo;
/**
*@authorleno
*Interfaz animal
*/
interfaz Animal
{ publicvoid comer(Comida comida); } /** *@authorleno *Una clase animal: gato */ clase Gato implementa Animal { publicvoid comer (Comida comida) { System.out.println("小猫吃"+food.getName()); } } / ** * @authorleno *Una clase animal: perro */ class Dog implements Animal { publicvoid comer (Comida comida ) { System.out.println("Cachorro masticando"+comida.getName()); } } /**
*@authorleno
*Clase abstracta de alimentos
*/
abstractclass Food
{ nombre de cadena protegida; cadena pública getName() { nombre de retorno; } publicvoid setName(nombre de cadena) { this.name = nombre; } } /** *@authorleno *Una especie de clase de comida: pescado */ clase Pescado extiende Comida { público Pescado(nombre de cadena) { this.name = nombre; } } /** *@authorleno *Una clase de alimento: hueso */ clase Hueso extiende Comida { público Hueso(nombre de cadena ) { este.nombre = nombre;
}
}
/**
*@authorleno
*Breeder class
*
*/
class Feeder
{ /** *El criador alimenta con un determinado tipo de alimento a un determinado tipo de animal *@paramanimal *@paramfood */ publicvoid feed(Animal animal,Food food) { animal.eat(food); } } /** *@authorleno *El alimentador de prueba alimenta a los animales con comida */ publicclass TestFeeder { publicstaticvoid main(String[] args) { Feeder feeder=new Feeder(); Animal animal= new Dog (); Food food=new Bone("Hueso de carne"); feeder.feed(animal,comida); //Alimenta al perro con huesos de carne
animal=new Cat();
food=new Fish("fish");
feeder.feed(animal,food); //Alimenta al gato con pescado
}
}
17. Describe el mecanismo de manejo de excepciones en JAVA
: durante la ejecución de el programa, como Cuando ocurre una excepción, se generará automáticamente un objeto de clase de excepción y el objeto de excepción se enviará al sistema de ejecución de Java. Este proceso se denomina lanzar una excepción. Java
: cuando el sistema de ejecución de Java recibe un objeto de excepción, buscará un código que pueda manejar la excepción y le entregará el objeto de excepción actual para su procesamiento. Este proceso se llama capturar la excepción.
• Si el sistema de ejecución de Java no puede encontrar un método que pueda detectar la excepción, el sistema de ejecución finalizará y se cerrará el programa Java correspondiente.
• Los programadores normalmente sólo pueden manejar excepciones (Excepción), pero no pueden hacer nada con respecto a los errores (Error).
18. Cree una clase en modo mónada y cargue el
paquete de archivos de propiedades solo una vez: com.softeem.demo,
importe java.io.FileInputStream,
importe java.io.FileNotFoundException,
importe java.io.IOException,
importe java.io.InputStream;
importar java.util.Properties;
/**
*@autorleno
*Modo único, que garantiza que el archivo de propiedades de configuración solo se cargue una vez durante toda la aplicación
*/
publicclass Singleton { instancia privatestatic Singleton; privatestaticfinal String CONFIG_FILE_PATH = "E:\\config.properties"; private Properties config; private Singleton() { config = new Properties(); InputStream es; try { is = new FileInputStream(CONFIG_FILE_PATH); config.load(is); is.close(); } catch (FileNotFoundException e) { // TODO Bloque de captura generado automáticamente e. printStackTrace() ; } catch (IOException e) { // TODO Bloque catch generado automáticamente
e.printStackTrace();
}
}
publicstatic Singleton getInstance()
{ if(instancia==null) { instancia = new Singleton(); } returninstance; } propiedades públicas getConfig() { returnconfig; } publicvoid setConfig(Configuración de propiedades) { this .config = config; } } l J2SE 19. Copie un directorio (archivo) a la ruta especificada /** *Copie un directorio o archivo a la ruta especificada *@paramsource *@paramtarget */ publicvoid copy(Fuente del archivo,Destino del archivo ) {
Archivo tarpath = nuevo archivo (destino, fuente.getName());
if(source.isDirectory())
{ tarpath.mkdir(); Archivo[] dir = source.listFiles(); for (int i = 0; i < dir.length; i++) { copiar(dir[i],tarpath); } }else { intentar { InputStream es = nuevo FileInputStream(fuente); Sistema operativo OutputStream = nuevo FileOutputStream(tarpath); byte[] buf = nuevobyte[1024]; longitud int = 0; while((len = is.read(buf))!=-1) { os.write(buf,0,len);
}
is.close();
os.close();
} catch (FileNotFoundException e) { // TODO Bloque de captura generado automáticamente e.printStackTrace(); } catch (IOException e) { // TODO Bloque de captura generado automáticamente e .printStackTrace(); } } } 20. Problema de retiro bancario usando un ejemplo de subprocesos múltiples en el paquete JAVAcom.softeem.demo; /** *@authorleno *La clase de cuenta * tiene un saldo de forma predeterminada y puede retirar dinero */ class Cuenta { balancefloatprivado = 1000; getBalancepublicfloat() { balanceretorno; }
publicvoid setBalance(saldo flotante) { this.balance = saldo; } /** *El método de retiro debe sincronizarse *@parammoney */ retiros publicsynchronizedvoid(dinero flotante) { if(saldo>=dinero) { System.out.println (" Quitado"+dinero+"元!"); intente { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Bloque de captura generado automáticamente e.printStackTrace(); } saldo-=dinero; } más {
System.out.println("¡Lo sentimos, saldo insuficiente!");
}
}
}
/**
*@authorleno
*Tarjeta bancaria
*/
class TestAccount1 extends Thread { cuenta privada cuenta; pública TestAccount1(Cuenta cuenta) { this.account = cuenta ; } @Override publicvoid run() { account.withdrawals(800); System.out.println("El saldo es:"+account.getBalance()+"yuan!"); } } / ** * @authorleno * Passbook */ class TestAccount2 extiende Thread { cuenta de cuenta privada; TestAccount2 pública (cuenta de cuenta) {
this.account = cuenta;
}
@Override
publicvoid run() { account.withdrawals(700); System.out.println("El saldo es:"+account.getBalance()+"Yuan!"); } } publicclass Prueba { publicstaticvoid main(String[] args) { Cuenta cuenta = nueva Cuenta(); TestAccount1 testAccount1 = nueva TestAccount1(cuenta); testAccount1.start(); TestAccount2 testAccount2 = nueva TestAccount2(cuenta); testAccount2.start(); } } 21. Uso de subprocesos múltiples en JAVA para probar el paquete de venta de boletos de estaciones de tren com.softeem.demo; /** *@authorleno *Clase de venta de boletos
*/
class SaleTicket implements Runnable { inttickets = 100; publicvoid run() { while (tickets > 0) { sale(); // O implementarlo así // sincronizado (this) { // if (tickets > 0) { // System.out.println(Thread.currentThread().getName() + "número de venta" // + (100 - entradas + 1) + "entradas"); // entradas--; // } // } } } publicsynchronizedvoid sale() { if (boletos > 0) { System.out.println(Thread.currentThread().getName() + "Vender"
+ (100 - boletos + 1) + "boletos");
boletos--;
}
}
}
publicclass TestSaleTicket { publicstaticvoid main(String[] args) { SaleTicket st = new SaleTicket(); new Thread(st, "No. 1 Window").start(); new Thread(st, "Ventana No. 2").start(); new Thread(st, "Ventana No. 3").start(); new Thread(st, "Ventana No. . 4") ).start(); } } 22. Uso de problemas de productor y consumidor de ejemplo de subprocesos múltiples en el paquete JAVA com.softeem.demo; clase Productor implementa Runnable { pila privada de SyncStack; Productor público (pila de SyncStack) { this. pila = pila; }
publicvoid run() { for (int i = 0; i < stack.getProducts().length; i++) { Cadena producto = "产品"+i; pila.push(producto); System.out.println("生产了: "+producto); prueba { Thread.sleep(200); } catch(InterruptedException e) { e.printStackTrace(); } } } } clase El consumidor implementa Runnable { pila privada de SyncStack; Consumidor público (pila SyncStack) { this.stack = pila; } ejecución publicvoid() {
for(int i=0;i <stack.getProducts().length;i++)
{ Cadena producto =stack.pop(); System.out.println("消费了: "+producto); prueba { Thread.sleep(1000); } catch(InterruptedException e) { e.printStackTrace(); } } } } clase SyncStack { cadena privada [] productos = nueva cadena [10]; índice privado; publicsynchronizedvoid push(String producto) { if(index==product.length()) {
prueba { espera(); } catch (InterruptedException e) { // TODO Bloque catch generado automáticamente e.printStackTrace(); } } notificar(); productos[índice]=producto; índice++; } publicsynchronized String pop() { if(index==0) { intentar { esperar(); } catch (InterruptedException e) { // TODO Bloque catch generado automáticamente e.printStackTrace(); } } notificar();
índice--;
Producto de cadena = productos[índice];
devolver producto;
}
cadena pública[] getProducts() { returnproducts; } } publicclass TestProducerConsumer { publicstaticvoid main(String[] args) { SyncStack stack=new SyncStack(); Productor p=nuevo Productor(pila); Consumidor c=nuevo Consumidor (pila); nuevo hilo(p).start(); nuevo hilo(c).start(); } }