Publicado por el cartel original: 2008-06-17 15:26:20
lJBS
1. Enumere 10 ventajas del lenguaje JAVA
a: Gratis, de código abierto, multiplataforma (independencia de plataforma), fácil de usar, funciones completas, orientado a objetos, robusto, multiproceso, estructura neutral, plataforma madura para aplicaciones empresariales, aplicaciones inalámbricas
2. Enumere 10 términos de programación orientada a objetos en JAVA
a: paquete, clase, interfaz, objeto, atributo, método, constructor, herencia, encapsulación, polimorfismo, abstracción, paradigma
3. Enumere 6 paquetes de uso común en JAVA
Java.lang;java.util;java.io;java.sql;java.awt;java.net;java.applet;javax.swing
4. ¿Cuáles son las funciones y características de los identificadores en JAVA? Función: Los identificadores se utilizan para nombrar variables, clases y métodos. Características: Además de comenzar con letras, los caracteres de subrayado "_" y "$" pueden ir seguidos de. letras, caracteres o números de guión bajo "_" y "$"
Java distingue entre mayúsculas y minúsculas y los identificadores no son una excepción
5. ¿Cuáles son las características de las palabras clave en JAVA? Enumere al menos 20 palabras clave.
Algunas palabras en Java a las que se les dan significados específicos y se usan para propósitos especiales se denominan palabras clave.
Todas las palabras clave de Java están en minúsculas, TURE, FALSE, NULL, etc. no son palabras clave de Java;
goto y const, aunque nunca se utilizan, están reservados como palabras clave de Java;
Hay un total de 51 palabras clave Java en •
resumen afirmar booleano romper byte continuar
case catch char clase const doble
por defecto se extiende de lo contrario flotador final
por mucho tiempo si implementa la importación
nueva instancia nula nativa de la interfaz int
paquete privado protegido público retorno corto
El superinterruptor estático estrictofp sincronizó esto
mientras que el lanzamiento nulo lanza el intento transitorio
volátil
6. ¿Cómo se clasifican los tipos de datos en JAVA?
Se puede dividir en tipos de datos simples y tipos de datos de referencia:
Tipos de datos simples: tipo numérico (byte, corto, int, largo, doble flotante), tipo de carácter (char), tipo booleano (booleano);
Tipos de datos de referencia: clase, interfaz, matriz.
7. Clasificación y ejemplos de operadores en JAVA
• Separador:,,;,[],()
• Operadores aritméticos: +, ―, *, /, %, ++, ――
• Operadores relacionales: >, <, >=, <=, ==, !=
• Operadores lógicos booleanos: !, &, |, ^, &&, ||
• Operadores de bits: &, |, ^, ~, >>, < <, >>>
• Operador de asignación: = Operador de asignación extendido: +=, ―=, *=, /=
• Operador de concatenación de cadenas: +
• Operador de forma: ()
8.La función y el uso de las palabras clave super y this.
• Utilice super en una clase Java para hacer referencia a componentes de la clase principal
– Se puede utilizar para acceder a atributos súper definidos en la clase principal.
– Se puede utilizar para llamar al método miembro superdefinido en la clase principal.
– Se puede utilizar para llamar al constructor de superclase super en el constructor de subclase
– La trazabilidad no se limita a la clase principal directa super
Para resolver el conflicto de nombres y el problema de incertidumbre de las variables, se introduce la palabra clave "esto" para representar el objeto actual del método en el que se encuentra. Java
– El constructor se refiere al nuevo objeto creado por el constructor.
– El método se refiere al objeto que llama al método.
• Uso de palabras clavethis
– Hacer referencia a las variables de instancia y métodos de la clase en el método o constructor de la propia clase.
– Pasar el objeto actual como parámetro a otros métodos o constructores.
– Se utiliza para llamar a otros constructores sobrecargados.
9. ¿Qué es una expresión en JAVA? ¿Qué hace?
• Una expresión es una combinación de operadores y operandos, y es un componente clave de cualquier lenguaje de programación.
• Las expresiones permiten a los programadores realizar cálculos matemáticos, comparación de valores, operaciones lógicas y manipulación de objetos en Java.
• Algunos ejemplos de expresiones:
-INCÓGNITA
–X+10
–Y=x+10
–Arr[10]
– estudiante.geName()
10. Haga una tabla que enumere todos los modificadores en JAVA y su ámbito de aplicación (¿pueden modificar constructores, propiedades, bloques libres, etc.)?
clase atributo constructor de métodos bloque libre clase interna
público AAAA AA
protegido YY YY
(Predeterminado) AAAAAA
privado YY YY
final AA AA AA
abstracto Y Y Y
estática s s s
11. Escribe un método para imprimir la tabla de multiplicar usando un bucle for.
/**
*Un bucle for imprime la tabla de multiplicar.
*/
publicvoid nueveNineMultiTable()
{
para (int i = 1,j = 1; j <= 9; i++) {
System.out.print(i+"*"+j+"="+i*j+" ");
si(yo==j)
{
yo=0;
j++;
Sistema.out.println();
}
}
}
12. Dado un objeto java.util.Date, cómo convertirlo en una cadena en el formato "2007-3-22 20:23:22"
/**
*Convertir una fecha en una cadena en un formato fijo
*@paramdate
*@returnstr
*/
cadena pública dateToStr (java.util.Fecha fecha)
{
SimpleDateFormat sdf = new SimpleDateFormat("aaaa-MM-dd HH:mm:ss");
Cadena cadena = sdf.format(fecha);
devolver cadena;
}
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 esPrimes(int n)
{
para (int i = 2; i <= Math.sqrt(n); i++) {
si(n%i==0)
{
retornofalso;
}
}
devolver verdadero;
}
14. Escribe un método que ingrese cualquier número entero y devuelva su factorial.
/**
*Obtener el factorial de cualquier número entero
*@paramn
*@regreso !
*/
publicint factorial(int n)
{
//recursión
si(n==1)
{
devolver 1;
}
devolver n*factorial(n-1);
//no recursivo
//intmulti = 1;
// para (int i = 2; i <= n; i++) {
// multi*=i;
// }
// devuelve 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, devuelva su posición de índice en la matriz. Si no existe, devuelva -1.
/**
*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 índice medio = (índice inicial+índice final)/2;
if(datos <conjunto de datos[beginIndex]||datos>conjunto de datos[endIndex]||beginIndex>endIndex)return -1;
if(datos <conjunto de datos[midIndex])
{
devolver binarioSearch(conjunto de datos,datos,beginIndex,midIndex-1);
}elseif(datos>conjunto de datos[midIndex])
{
devolver binarioSearch(conjunto de datos,datos,midIndex+1,endIndex);
}demás
{
devolver índice medio;
}
}
/**
*Búsqueda binaria de la posición de un número entero específico en la matriz de enteros (no recursiva)
*@paramdataset
*@paramdata
*@returnindex
*/
publicint binarioSearch(int[] conjunto de datos,int datos)
{
int índicecomienzo = 0;
int endIndex = conjunto de datos.longitud - 1;
int índice medio = -1;
if(datos <conjunto de datos[beginIndex]||datos>conjunto de datos[endIndex]||beginIndex>endIndex)return -1;
while(inicioIndex <= endIndex) {
índice medio = (índice inicio+índice final)/2;
if(datos <conjunto de datos[midIndex]) {
endIndex = midIndex-1;
} elseif(datos>conjunto de datos[midIndex]) {
comenzarIndice = midIndex+1;
}demás
{
devolver índice medio;
}
}
devolver -1;
}
16. Un ejemplo de un criador que alimenta a los animales con comida refleja el pensamiento orientado a objetos en JAVA y la utilidad de las interfaces (clases abstractas).
paquete com.softeem.demo;
/**
*@autorleno
*Interfaz de animales
*/
interfaz animales
{
publicvoid comer(Comida comida);
}
/**
*@autorleno
*un tipo de animal: gato
*/
clase Gato implementa Animal
{
comer publicvoid (comida comida)
{
System.out.println("El gatito come"+comida.getName());
}
}
/**
*@autorleno
*un tipo de animal: perro
*/
clase Perro implementa Animal
{
comer publicvoid (comida comida)
{
System.out.println("Cachorro masticando"+food.getName());
}
}
/**
*@autorleno
*Clase abstracta de comida.
*/
resumenclasecomida
{
nombre de cadena protegida;
cadena pública getName() {
nombre de retorno;
}
publicvoid setName (nombre de cadena) {
this.nombre = nombre;
}
}
/**
*@autorleno
*Un grupo de alimentos: pescado
*/
clase Pescado extiende Comida
{
pez público (nombre de cadena) {
this.nombre = nombre;
}
}
/**
*@autorleno
*Un grupo de alimentos: huesos
*/
clase Hueso extiende Comida
{
hueso público (nombre de cadena) {
this.nombre = nombre;
}
}
/**
*@autorleno
*Categoría de criador
*
*/
alimentador de clases
{
/**
*El criador alimenta con un determinado tipo de alimento a un determinado tipo de animal.
*@paramanimal
*@paramfood
*/
alimentación pública vacía (animal animal, alimento alimenticio)
{
animal.comer(comida);
}
}
/**
*@autorleno
*Prueba de criadores que alimentan a los animales con comida.
*/
clase pública TestFeeder {
publicstaticvoid principal (cadena [] argumentos) {
Alimentador alimentador=nuevo alimentador();
Animal animal=nuevo Perro();
Comida comida = hueso nuevo ("hueso de carne");
feeder.feed(animal,comida); //Alimenta al perro con huesos de carne
animal=nuevo Gato();
comida = pez nuevo ("pez");
feeder.feed(animal,comida); //Alimenta al gato con pescado
}
}
18. Cree una clase monomodo y cargue el archivo de propiedades solo una vez
paquete 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, que garantiza que el archivo de propiedades de configuración solo se cargue una vez durante toda la aplicación
*/
clase pública Singleton {
instancia singleton estática privada;
cadena privatestaticfinal CONFIG_FILE_PATH = "E:\config.properties";
configuración de propiedades privadas;
singleton privado()
{
config = nuevas Propiedades();
Flujo de entrada es;
intentar {
es = nuevo FileInputStream(CONFIG_FILE_PATH);
config.load(es);
es.close();
} captura (FileNotFoundException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
} captura (IOException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
getInstance publicstatic Singleton()
{
si (instancia == nulo)
{
instancia = nuevo Singleton();
}
instancia de retorno;
}
Propiedades públicas getConfig() {
returnconfig;
}
publicvoid setConfig(Configuración de propiedades) {
this.config = configuración;
}
}
lJ2SE
19. Copie un directorio (archivo) a la ruta especificada
/**
*Copiar un directorio o archivo a la ruta especificada
*@paramsource
*@paramtarget
*/
copia publicvoid (origen del archivo, destino del archivo)
{
Archivo tarpath = nuevo archivo (destino, fuente.getName());
si(fuente.isDirectory())
{
tarpath.mkdir();
Archivo[] dir = source.listFiles();
for (int i = 0; i < dir.length; i++) {
copiar(dir[i],tarpath);
}
}demás
{
intentar {
InputStream es = nuevo FileInputStream(fuente);
Sistema operativo OutputStream = nuevo FileOutputStream(tarpath);
byte[] buf = nuevobyte[1024];
int longitud = 0;
mientras((len = is.read(buf))!=-1)
{
os.write(buf,0,len);
}
es.close();
os.cerrar();
} captura (FileNotFoundException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
} captura (IOException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
}
20. Ejemplo de problema de retiro bancario usando subprocesos múltiples en JAVA
paquetecom.softeem.demo;
/**
*@autorleno
*Tipo de cuenta
*Hay saldo por defecto y puedes retirar dinero
*/
cuenta de clase {
saldo de flotación privada = 1000;
getBalance público flotante() {
saldo de retorno;
}
publicvoid setBalance(saldo flotante) {
this.saldo = saldo;
}
/**
*Los métodos de retiro deben estar sincronizados
*@parammoney
*/
retiros vacíos sincronizados públicamente (dinero flotante)
{
si(saldo>=dinero)
{
System.out.println("Tomado"+dinero+"Yuan!");
intentar {
Hilo.dormir(1000);
} captura (Excepción interrumpida e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
saldo-=dinero;
}
demás
{
System.out.println("Lo sentimos, ¡saldo insuficiente!");
}
}
}
/**
*@autorleno
*tarjeta bancaria
*/
clase TestAccount1 extiende el hilo {
cuenta de cuenta privada;
cuenta de prueba pública1 (cuenta de cuenta) {
esta.cuenta = cuenta;
}
@Anular
ejecución pública vacía () {
cuenta.retiros(800);
System.out.println("El saldo es:"+account.getBalance()+"Yuan!");
}
}
/**
*@autorleno
*Libreta de depósitos
*/
clase TestAccount2 extiende el hilo {
cuenta de cuenta privada;
cuenta de prueba pública2 (cuenta de cuenta) {
esta.cuenta = cuenta;
}
@Anular
ejecución pública vacía () {
cuenta.retiros(700);
System.out.println("El saldo es:"+account.getBalance()+"Yuan!");
}
}
prueba de clase pública
{
publicstaticvoid principal (cadena [] argumentos) {
Cuenta cuenta = nueva Cuenta();
TestAccount1 testAccount1 = nueva TestAccount1 (cuenta);
testAccount1.start();
TestAccount2 testAccount2 = nueva TestAccount2 (cuenta);
testAccount2.start();
}
}
21. Utilice subprocesos múltiples en JAVA para dar un ejemplo del problema de venta de boletos en una estación de tren.
paquete com.softeem.demo;
/**
*@autorleno
*Venta de entradas
*/
clase SaleTicket implementa Runnable {
entradas = 100;
ejecución pública vacía () {
mientras (entradas > 0) {
venta();
//O implementarlo así
// sincronizado (esto) {
// si (boletos > 0) {
// System.out.println(Thread.currentThread().getName() + "Vender el primero"
// + (100 - entradas + 1) + "entradas");
// entradas--;
// }
// }
}
}
venta publicsynchronizedvoid() {
si (boletos > 0) {
System.out.println(Thread.currentThread().getName() + "Vender primero"
+ (100 - entradas + 1) + "entradas");
entradas--;
}
}
}
clase pública TestSaleTicket {
publicstaticvoid principal (cadena [] argumentos) {
Boleto De Venta st = nuevo Boleto De Venta();
new Thread(st, "Ventana nº 1").start();
new Thread(st, "Ventana nº 2").start();
new Thread(st, "Ventana nº 3").start();
nuevo hilo(st, "Ventana nº 4").start();
}
}
22. Ejemplo de problemas de productores y consumidores al utilizar subprocesos múltiples en JAVA
paquete com.softeem.demo;
clase Productor implementa Runnable
{
pila privada de SyncStack;
Productor público (pila SyncStack) {
this.stack = pila;
}
ejecución pública vacía () {
para (int i = 0; i < pila.getProducts().length; i++) {
Producto de cadena = "producto"+i;
pila.push(producto);
System.out.println("Producido: "+producto);
intentar
{
Hilo.dormir(200);
}
captura (Excepción interrumpida e)
{
e.printStackTrace();
}
}
}
}
clase Consumidor implementa Ejecutable
{
pila privada de SyncStack;
Consumidor público (pila SyncStack) {
this.stack = pila;
}
ejecución pública vacía () {
for(int i=0;i <stack.getProducts().length;i++)
{
Producto de cadena =stack.pop();
System.out.println("Consumido: "+producto);
intentar
{
Hilo.dormir(1000);
}
captura (Excepción interrumpida e)
{
e.printStackTrace();
}
}
}
}
clase SyncStack
{
productos de cadena privada [] = nueva cadena [10];
índice privado;
push vacío público sincronizado (producto de cadena)
{
si(índice==producto.longitud())
{
intentar {
esperar();
} captura (Excepción interrumpida e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
notificar();
productos[índice]=producto;
índice++;
}
pop de cadena sincronizado públicamente ()
{
si(índice==0)
{
intentar {
esperar();
} captura (Excepción interrumpida e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
notificar();
índice--;
Producto de cadena = productos[índice];
devolver producto;
}
Cadena pública[] getProductos() {
productos devueltos;
}
}
clase pública TestProducerConsumer {
publicstaticvoid principal (cadena [] argumentos) {
Pila SyncStack=nueva SyncStack();
Productor p=nuevo Productor(pila);
Consumidor c=nuevo Consumidor (pila);
nuevo hilo(p).start();
nuevo hilo(c).start();
}
}
23. Programación para realizar la transmisión de objetos de Estudiante serializados (sno, sname) en la red.
paquete 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;
clase Estudiante implementa Serializable {
privado ent sno;
nombre de cadena privada;
Estudiante público (int sno, nombre de cadena) {
this.sno = sno;
this.nombre = nombre;
}
público int getSno() {
volver sno;
}
conjunto vacío públicoSno (int sno) {
this.sno = sno;
}
cadena pública getNombre() {
devolver nombre;
}
setSname público vacío (nombre de cadena) {
this.nombre = nombre;
}
@Anular
cadena pública toString() {
return "Número de estudiante:" + sno + ";Nombre:" + sname;
}
}
clase MiCliente extiende el hilo {
@Anular
ejecución pública vacía() {
intentar {
Socket s = nuevo Socket("localhost", 9999);
ObjectInputStream ois = new ObjectInputStream(s.getInputStream());
Estudiante estu = (Estudiante) ois.readObject();
System.out.println("El programa cliente recibe el objeto de estudiante transferido desde el programa servidor >> " + stu);
ois.close();
s.cerrar();
} captura (IOException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
} captura (ClassNotFoundException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
}
clase MiServidor extiende el hilo {
@Anular
ejecución pública vacía() {
intentar {
ServerSocket ss = nuevo ServerSocket(9999);
Enchufe s = ss.accept();
Operaciones de ObjectOutputStream = new ObjectOutputStream(s.getOutputStream());
Estudiante estudiante = nuevo Estudiante(1, "Zhao Benshan");
ops.writeObject(stu);
operaciones.close();
s.cerrar();
ss.cerrar();
} captura (IOException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
}
transferencia de prueba de clase pública {
público estático vacío principal (String [] argumentos) {
nuevo MiServidor().start();
nuevo MiCliente().start();
}
}
lJDBC
24. Utilice el componente dom4j para analizar los siguientes archivos en formato XML:
<?xml versión="1.0" codificación="UTF-8"?>
<generador>
<nombre de tabla="iniciar sesión" operación="1">
<columna nombre="nombre de usuario" handle="0">aaa </columna>
<columna nombre="contraseña" handle="0">123 </columna>
</tabla>
<nombre de tabla="iniciar sesión" operación="2">
<columna nombre="id" handle="1">1 </columna>
<columna nombre="nombre de usuario" handle="0">bbb </columna>
<columna nombre="contraseña" handle="0">444 </columna>
</tabla>
<nombre de tabla="iniciar sesión" operación="3">
<columna nombre="id" handle="1">4 </columna>
</tabla>
</generador>
Reglas: <tabla>operación 1 insertar tabla, actualizar tabla 2, eliminar tabla 3.
<columna>la tabla de manejo 1 se usa como condición donde, la tabla 0 se usa como campo de operación.
Requisito: ¡Genere tres declaraciones SQL de acuerdo con las reglas! (Es decir, cree un método para analizar el archivo xml y generar una cadena que contenga tres declaraciones SQL)
/**
*Analizar el archivo XML para generar una cadena que contenga sentencias SQL ejecutables
*@paramxmlNombreArchivo
*@returnSQL
*/
cadena pública parseXmltoSQL (String xmlFileName) {
StringBuffer sbsql = nuevo StringBuffer();
Lector SAXReader = nuevo SAXReader();
intentar {
Documento documento = lector.read(nuevo archivo(xmlFileName));
Elemento elemento = document.getRootElement();
Iterador it = element.elementIterator("tabla");
mientras (it.hasNext()) {
elemento = (Elemento) it.next();
//Obtener operaciones en la mesa
Operador de cadena = element.attributeValue("operación");
//Obtener el nombre de la tabla
String tableName = element.attributeValue("nombre");
si ("1".equals(oper)) {
sbsql.append("insertar en ").append(nombretabla);
Iterador it2 = element.elementIterator("columna");
Cadena nombreColumna1 = nulo;
Cadena columnValue1 = nulo;
Cadena nombreColumna2 = nulo;
Cadena columnValue2 = nulo;
si (it2.hasNext()) {
elemento = (Elemento) it2.next();
columnName1 = element.attributeValue("nombre");
columnValue1 = elemento.getText();
}
si (it2.hasNext()) {
elemento = (Elemento) it2.next();
columnName2 = element.attributeValue("nombre");
columnValue2 = elemento.getText();
}
sbsql.append("("+NombreColumna1+","+NombreColumna2+")"+" valores('"+ValorColumna1+"','"+ValorColumna2+"')n");
} elseif ("2".equals(oper)) {
sbsql.append("actualizar ").append(nombretabla);
Iterador it2 = element.elementIterator("columna");
Cadena nombreColumna1 = nulo;
Cadena columnValue1 = nulo;
Cadena nombreColumna2 = nulo;
Cadena columnValue2 = nulo;
Cadena nombreColumna3 = nulo;
Cadena columnValue3 = nulo;
si (it2.hasNext()) {
elemento = (Elemento) it2.next();
columnName1 = element.attributeValue("nombre");
columnValue1 = elemento.getText();
}
si (it2.hasNext()) {
elemento = (Elemento) it2.next();
columnName2 = element.attributeValue("nombre");
columnValue2 = elemento.getText();
}
si (it2.hasNext()) {
elemento = (Elemento) it2.next();
columnName3 = element.attributeValue("nombre");
columnValue3 = elemento.getText();
}
sbsql.append(" set "+columnName2+"='"+columnValue2+"',"+columnName3+"='"+columnValue3+"' donde "+columnName1+"="+columnValue1+"n");
}elseif ("3".equals(oper)) {
sbsql.append("eliminar de ").append(nombretabla);
Iterador it2 = element.elementIterator("columna");
Cadena nombreColumna1 = nulo;
Cadena columnValue1 = nulo;
si (it2.hasNext()) {
elemento = (Elemento) it2.next();
columnName1 = element.attributeValue("nombre");
columnValue1 = elemento.getText();
}
sbsql.append(" donde "+columnName1+"="+columnValue1);
}
}
} captura (DocumentException e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
devolver sbsql.toString();
}
lJSP/SERVLET
25. Escriba los objetos integrados de JSP y explique sus funciones.
solicitud: solicitud representa el objeto HttpServletRequest. Contiene información sobre la solicitud del navegador y proporciona varios métodos útiles para obtener cookies y datos de encabezado. respuesta:respuesta representa el objeto HttpServletResponse y proporciona varios métodos para configurar la respuesta enviada al navegador (como cookies, información de encabezado, etc.). El objeto out:out es una instancia de javax.jsp.JspWriter y proporciona varios métodos que usted puede utilizar para enviar la salida al navegador. pageContext: pageContext representa un objeto javax.servlet.jsp.PageContext. Es una API que se utiliza para facilitar el acceso a diversos ámbitos de espacios de nombres y objetos relacionados con servlets, y envuelve métodos de funciones comunes relacionadas con servlets. sesión: sesión representa un objeto javax.servlet.http.HttpSession solicitado. La sesión puede almacenar información de estado del usuario en la aplicación: la aplicación representa un objeto javax.servle.ServletContext. Esto ayuda a encontrar información sobre el motor de servlet y el entorno de servlet. config:config representa un objeto javax.servlet.ServletConfig. Este objeto se utiliza para acceder a los parámetros de inicialización de la instancia del servlet. página: página representa una instancia de servlet generada a partir de esta página.
excepción: el objeto de excepción es un objeto de excepción cuando ocurre una excepción durante la ejecución de una página, se genera este objeto. Si una página JSP quiere utilizar este objeto, debe establecer isErrorPage en verdadero; de lo contrario, no se puede compilar. En realidad, es la contraparte de java.lang.Throwable.