JAVA中最常见基础面试题

拼搏现实的明天。 2022-12-25 10:00 401阅读 0赞

### JAVA中最常见面试题 ###

*  1.javac java命令
 *  2.int i=20000000000000;报错吗？为什么？
 *  3.B（browser）/S（server） 跟C（client）/S（server）架构区别是什么？
 *  4.整数有哪几种类型？
 *  5.float f=3.14 ; 报错吗？为什么？
 *  6.3.14是什么类型？
 *  7.java中有哪些基本数据类型？
 *  8.int a = 5 ;b = a++ + ++a +3 + a++ ；a和b是多少?
 *  9.①short s = 1 ;s = s + 1 ;有错吗？为什么？②short s = 1 ;s += 1 ;有错吗？为什么？
 *  10.System.out.println(5>3?9:3.1);结果会打印出什么？
 *  11.final的用法？
 *  12.long a=1L,switch(a) 结果打印什么？
 *  13.给数组排序
 *  14.堆跟栈的区别
 *  15.java中可以多继承吗？
 *  16.重写跟重载的区别？
 *  17.常量属性的赋值方式？
 *  18.java的三大特性？
 *  19.说几个访问修饰符的区别？
 *  20.请说出5个运行时异常？ 请说出5个常见的类？说出5个常见的包？
 *  21.父类代码块、父类静态代码块、父类构造方法、子类代码块、子类静态代码块、子类构造方法，执行顺序如何？
 *  22.final、finally、finalize区别？
 *  23.“==”跟equals的区别？
 *  24.ArrayList元素用循环全部删除。
 *  25.浅谈一下String, StringBuffer，StringBuilder的区别？
 *  26.下面的代码将创建几个字符串对象？
 *  27.在java中，String s=new String("xyz");创建了几个对象？（ B）
 *  28.下面的代码输出什么？
 *  29.下面的代码输入什么？
 *  30.下面的代码输出什么？
 *  31.下面的代码输出什么？
 *  32.下面的代码输出什么？
 *  33.下面的代码输出什么？
 *  34.下面的代码输入什么？
 *  35.下面的代码输入什么？
 *  36.下面选项结果为true的是
 *  37.Math.round(5.5)、Math.round(-5.5)分别输出多少？
 *  38.下面的代码输入什么？
 *  39.ArrayList跟Vector的对比？
 *  40.List Set Map的区别？
 *  41.说下HashTable HashMap的区别？
 *  42.HashMap（HashSet）用来装学生，人数在37-43人左右，请问如何初始化HashMap数量达到性能最优？
 *  43.重写equals是否需要重写hashcode？ 重写hashcode是否需要重写equals？
 *  44.说下数组跟链表的区别？
 *  45.throw跟throws区别？
 *  46.你知道哪些JDK8新特性？
 *  47.where跟having的区别？
 *  48.JS中"= ="跟"= = ="有什么区别？
 *  49.请说下xml跟json的区别？
 *  50.请说下3次握手跟4次挥手？
 *  51.断开连接的时候客户端为什么需要的等待2MSL时间？
 *  52.servlet是单线程还是多线程？是单例的吗？
 *  53.请说下servlet的生命周期？
 *  54.get请求与post的请求的区别是什么？
 *  55.请求转发跟请求重定向的区别是什么？
 *  56.JSP是服务器端页面还是客户端页面？
 *  57.jsp的本质是一个servlet？
 *  58.静态包含（指令）跟动态包含（动作）有什么区别
 *  59.JSP的9大内置对象？
 *  60.会话跟踪的几种技术？

# 1.javac java命令 #

> javac编译命令： javac Test.java， 将.java文件编译成.class字节码文件。  
> java运行命令：java Test， 运行.class文件。

# 2.int i=20000000000000;报错吗？为什么？ #

> 会,因为超过了int取值范围， java中int的取值范围为-2147483648到+2147483648。21亿左右

# 3.B（browser）/S（server） 跟C（client）/S（server）架构区别是什么？ #

> B/S结构即浏览器和服务器架构， 特点是体验要求一般，加载资源少；升级方便、无需安装、维护便利、跨平台。

> C/S结构即客户端和服务器架构 ，特点是体验要求极高，加载资源多；升级不方便、安装不方便、维护不方便、不跨平台。

# 4.整数有哪几种类型？ #

> byte（1字节）, short（2字节）, int（4字节）, long（8字节）

# 5.float f=3.14 ; 报错吗？为什么？ #

> 会，3.14是double型的。 要加f 或加float强转

# 6.3.14是什么类型？ #

> 小数默认double型

# 7.java中有哪些基本数据类型？ #

> 四类八种 整型：byte short int long 浮点型：float double 字符型：char 布尔：boolean

# 8.int a = 5 ;b = a++ + ++a +3 + a++ ；a和b是多少? #

int a = 5 ;
    	int b = a++ + ++a +3 + a++ ;
    	System.out.println(a);
    	System.out.println(b); 
    
    	b = a++ + ++a +3 + a++ 
    		5（6）+7（7）+3+7（8）
    		a=8
    		b=22

# 9.①short s = 1 ;s = s + 1 ;有错吗？为什么？②short s = 1 ;s += 1 ;有错吗？为什么？ #

> ①会报错，因为整数的数据类型默认是int类型，等号右边的s+1操作，s+1后变为int类型，等号左边是short类型，所以会报错。  
> ②不会报错，因为s+=1相当于 s = (short)(s + 1); 其中有隐含的强制类型转换

# 10.System.out.println(5>3?9:3.1);结果会打印出什么？ #

> 9.0  
> 因为它总体返回值是double，所以9被转型了

# 11.final的用法？ #

> 1、当修饰属性的时候表示常量  
> 2、当修饰方法的时候表示这个方法不能被重写，子类可以调用  
> 3、当修饰类的时候表示不能被继承

# 12.long a=1L,switch(a) 结果打印什么？ #

> 会报错，因为switch的（）中不能是long 类型，会报错。

# 13.给数组排序 #

> 快速排序法、冒泡法、选择排序法、插入排序法、数组的sort方法  
> Arrays.sort(arr);

# 14.堆跟栈的区别 #

> 1.存储  
> 栈存储：变量、对象的引用，堆存储实例对象  
> 2、速度  
> 栈：存取速度快  
> 堆：存取速度慢  
> 3、线程访问  
> 栈：每个线程都有一个栈区  
> 堆：所有线程共享一个堆区  
> 4、垃圾回收  
> 栈：比较频繁  
> 堆：不频繁  
> 如果想详解学习请参考本博主的这篇博客：[内存分析详解（栈、堆和方法区）程序执行的内存变化过程][Link 1]

# 15.java中可以多继承吗？ #

> 不可以。只能单继承,但是可以多实现

# 16.重写跟重载的区别？ #

> 重载：同一个类中，方法名相同,参数不同(无关返回值)。典型应用：无参构造和有参构造  
> 重写：不同的类当中，方法名相同，参数相同，返回值相同，并且两者要有继承关系。

# 17.常量属性的赋值方式？ #

> 第一种：使用一个static静态代码块来指定，然后在静态代码块中，我们去动态读取外部的一个Properties文件的值。  
> 第二种：我们可以配置Java的运行时配置，来指定一个-Dname=value的参数，这样也可以在类内部动态的接受到运行时指定的一个参数。  
> 第三种：我们还可以读的到系统配置的PATH或者CLASSPATH里面的值，同理，我们也可以配置自己的环境变量，然后在程序中一样也能读到这些配置的环境变量

# 18.java的三大特性？ #

> 封装：隐藏类的属性和实现细节，仅对外提供公共访问方式。  
> 继承：子类继承父类的属性和方法，并能扩展新的能力。  
> 多态：父类接受子类的对象，可以调用子类重写父类的方法。

# 19.说几个访问修饰符的区别？ #

<table> 
 <thead> 
  <tr> 
   <th>修饰符\作用域</th> 
   <th>同一个类中</th> 
   <th>同一个包中</th> 
   <th>子类中</th> 
   <th>任何地方</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>private</td> 
   <td>可以</td> 
   <td>不可以</td> 
   <td>不可以</td> 
   <td>不可以</td> 
  </tr> 
  <tr> 
   <td>默认修饰符</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>不可以</td> 
   <td>不可以</td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>不可以</td> 
  </tr> 
  <tr> 
   <td>public</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>可以</td> 
  </tr> 
 </tbody> 
</table>

> Public：对外公开  
> Protected：受保护的，同一个包的子类可以访问。  
> 默认修饰符：同一个包中可以访问  
> Private：只在当前类有效

# 20.请说出5个运行时异常？ 请说出5个常见的类？说出5个常见的包？ #

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>异常名称</th> 
   <th>异常描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>java.lang.NullPointerException</td> 
   <td>空指针异常:对象（引用）为空，并且调用相应方法。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>java.lang.ClassNotFoundException</td> 
   <td>找不到指定类</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>java.lang.ArrayIndexOutOfBoundsException</td> 
   <td>数组下标越界</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>java.lang.NumberFormatException</td> 
   <td>数字格式化异常</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>java.lang.ArithmeticException</td> 
   <td>数学运算异常</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>java.lang.ClassCastException</td> 
   <td>类型转换异常，向下转型中经常发生</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>java.text.ParseException</td> 
   <td>时间格式化异常，SimpleDateFormart中经常发生</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>java.util.InputMismatchException</td> 
   <td>输入类型不匹配异常</td> 
  </tr> 
 </tbody> 
</table>

> 类:Object、String、System、File、HashMap、Date、Class  
> 包:java.lang ，java.io， java.util， java.sql，javax.servlet

# 21.父类代码块、父类静态代码块、父类构造方法、子类代码块、子类静态代码块、子类构造方法，执行顺序如何？ #

> 静态代码在加载时就运行  
> 执行顺序：父类静态代码块–>子类静态代码块–>父类代码块–>子类代码块–>父类构造方法->子类构造方法

# 22.final、finally、finalize区别？ #

> final是修饰符，可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。  
> finalize是一个属于Object类的一个方法，在对象被回收前调用的方法，用于回收资源。Object类是所有类的父类，该方法一般由垃圾回收器来调用，当我们调用System.gc() 方法的时候，由垃圾回收器调用finalize()来回收垃圾，是一个对象是否可回收的最后判断。  
> finally在try/catch语句中用来处理异常处理的一部分，通常我们将一定要执行的代码方法finally代码块中，表示不管是否出现异常，这段代码块最终一定会被执行，一般用来存放一些关闭资源的代码。

# 23.“==”跟equals的区别？ #

> “==”是运算符，如果是基本数据类型，则比较**存储的值**；如果是引用数据类型，则比较**所指向对象的地址值**。  
> equals是Object的方法，比较的是**所指向的对象的地址值**，一般情况下，重写之后比较的是**对象的值**。  
> 如果想详解学习请参考本博主的这篇博客：[详解“==”和equals的区别][equals]

# 24.ArrayList元素用循环全部删除。 #

//迭代器
    Iterator<String> iterator = list.iterator();
    while(iterator.hasNext()){
        
            iterator.remove();
    }

# 25.浅谈一下String, StringBuffer，StringBuilder的区别？ #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70]

# 26.下面的代码将创建几个字符串对象？ #

String s1 = new String("Hello");  
    String s2 = new String("Hello");
    2个或3个
    >首先s1和s2会在堆空间中创建2个对象，然后指向常量池中的"Hello"。但是如果常量池中没有"Hello"，那么就会现在常量池中创建一个“Hello”。

# 27.在java中，String s=new String(“xyz”);创建了几个对象？（ B） #

A   1个    B 1个或2个      C  2个     D 以上都不对

> 如果"xyz"在常量池中存在，只会在堆中创建一个new String(“xyz”) ；一个对象  
> 如果"xyz"在常量池中不存在，会现在常量池中创建一个“xyz”,然后在堆中创建一个new String(“xyz”)；两个对象

# 28.下面的代码输出什么？ #

String s1 = new String("abc");
    String s2 = new String("abc");
    System.out.println(s1 == s2);//false
    System.out.println(s1.equals(s2));  //true

# 29.下面的代码输入什么？ #

String s1 = "abc";
    String s2 = new String("abc");
    s2.intern();
    System.out.println(s1 ==s2);//false

# 30.下面的代码输出什么？ #

String s1= "abc";
    	String s2= "abc";
    	String s3 = new String("abc");  
    	String s4 = new String("abc"); 
    	System.out.println("s3 == s4 : "+(s3==s4)); //false
    	System.out.println("s3.equals(s4) : "+(s3.equals(s4)));  //true
    	System.out.println("s1 == s3 : "+(s1==s3));  //false
    	System.out.println("s1.equals(s3) : "+(s1.equals(s3)));//true 
    	System.out.println(s1==s2); //true

# 31.下面的代码输出什么？ #

String str1 = "ab" + "cd"; 
    String str11 = "abcd";   
    System.out.println("str1 = str11 : "+ (str1 == str11)); //true

# 32.下面的代码输出什么？ #

String str2 = "ab"; 
    String str3 = "cd";
    String str4 = str2+str3;  
    String str5 = "abcd"; 
    System.out.println("str4 = str5 : " + (str4==str5));//false

# 33.下面的代码输出什么？ #

final String str2 = "ab"; 
    final String str3 = "cd";
    String str4 = str2+str3;  
    String str5 = "abcd"; 
    System.out.println("str4 = str5 : " + (str4==str5));//true

# 34.下面的代码输入什么？ #

String str6 = "b";  
    String str7 = "a" + str6;  
    String str67 = "ab";  
    System.out.println("str7 = str67 : "+ (str7 == str67));  //false

# 35.下面的代码输入什么？ #

final String str8 = "b";  
    String str9 = "a" + str8;  
    String str89 = "ab";  
    System.out.println("str9 = str89 : "+ (str9 == str89));  //true

# 36.下面选项结果为true的是 #

String s1=”Hello”;
     String s2=”hello”;
     String s3=s1.toLowerCase();
     String s4=s2.toLowerCase();
    	下面选项结果为true的是：C
    	A.S1==s3	
    	B.S2==s3
    	C.S2==s4	
    	D.S3==s4

# 37.Math.round(5.5)、Math.round(-5.5)分别输出多少？ #

> 6,-5  
> Math.round()方法可以这样理解：将括号内的数+0.5之后，向下取整。  
> 比如：round(3.4)就是3.4+0.5=3.9，向下取值是3，所以round(3.4)=3;  
> round(-10.5)就是-10.5+0.5=-10，向下取值就是-10，所以round(-10.5)=-10。  
> 所以，Math.round(11.5)=12;Math.round(-11.5)=-11；Math.round(5.5)=6、Math.round(-5.5)=-5.

# 38.下面的代码输入什么？ #

Integer i1 = 1 ;
    	Integer i2 = 1 ;
    	Integer i3 = 128 ;
    	Integer i4 = 128 ;		
    	System.out.println(i1 == i2); //true  
    	System.out.println(i3 == i4);  //false

> Integer类型在-128~127之外会new新对象

# 39.ArrayList跟Vector的对比？ #

> 相同点：  
> （1）两者都是基于索引的，内部由一个数组支持。  
> （2）两者维护插入的顺序，我们可以根据插入顺序来获取元素。  
> （3）ArrayList和Vector的迭代器实现都是fail-fast的。  
> （4）ArrayList和Vector两者允许null值，也可以使用索引值对元素进行随机访问。  
> 不同点：  
> （1）Vector是同步的，而ArrayList不是。然而，如果你寻求在迭代的时候对列表进行改变，你应该使用CopyOnWriteArrayList。  
> （2）ArrayList比Vector快，它因为有同步，不会过载。  
> （3）ArrayList更加通用，因为我们可以使用Collections工具类轻易地获取同步列表和只读列表。

# 40.List Set Map的区别？ #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70 1]

> List和Set都是Collection的子接口，而Map不是。  
> List存的元素都是有序、可重复的，而Set是无序的、不可重复的，而Map是key和value的键值对，key不可重复，value随意。

# 41.说下HashTable HashMap的区别？ #

> 1、HashMap是非线程安全的，HashTable是线程安全的。  
> 2、HashMap的键和值都允许有null值存在，而HashTable则不行。  
> 3、因为线程安全的问题，HashMap效率比HashTable的要高。  
> 4、Hashtable是同步的，而HashMap不是。因此，HashMap更适合于单线程环境，而Hashtable适合于多线程环境。  
> 5.HashMap初始容量是16，每次扩容只能是2的幂次方；HashTable每次扩容至2倍。

# 42.HashMap（HashSet）用来装学生，人数在37-43人左右，请问如何初始化HashMap数量达到性能最优？ #

> 64

# 43.重写equals是否需要重写hashcode？ 重写hashcode是否需要重写equals？ #

> 不一定  
> 需要

# 44.说下数组跟链表的区别？ #

> 1.数组静态分配内存（长度固定），链表动态分配内存（长度不固定）；  
> 2.数组在内存中存储的元素是连续的，链表不连续；  
> 3.数组元素在栈区，链表元素在堆区；  
> 4.与数组的区别 从增删改查操作的效率上来谈  
> 增删： 链表的效率更高  
> 改查： 数组的效率更高

# 45.throw跟throws区别？ #

> throw：写在java语句中，用来在程序中明确的抛出异常  
> throws：写在定义的方法后面，用来表明方法不能处理的异常。

# 46.你知道哪些JDK8新特性？ #

> 接口 lambda表达式 函数引用

# 47.where跟having的区别？ #

> where子句: 是在分组之前使用，表示从所有数据中筛选出部分数据，以完成分组的要求， 在where子句中不允许使用统计函数，没有group by子句也可以使用。  
> having子句： 是在分组之后使用的，表示对分组统计后的数据执行再次过滤，可以使用统计函数，有group by子句之后才可以出现having子句。

# 48.JS中"= =“跟”= = ="有什么区别？ #

== 表示相等 （值相等）
    ===表示恒等（类型和值都要相等）

# 49.请说下xml跟json的区别？ #

> 区别：  
> 1、传输同样格式的数据，xml需要使用更多的字符进行描述，  
> 2、 流行的是基于json的数据传输。  
> 3、xml的层次结构比json更清晰。

# 50.请说下3次握手跟4次挥手？ #

> 三次握手：  
> 第一次握手：客户端发送第一个包，其中SYN标志位为1, ACK=0，发送顺序号sequence=X(随机int)。客户端进入SYN发送状态，等待服务器确认。  
> 第二次握手：服务器收到这个包后发送第二个包，其中包SYN、ACK标志位为1，发送顺序号seq=Y(随机int)，接收顺序号ACK=X+1，此时服务器进入SYN接收状态。  
> 第三次握手：客户端收到服务器传来的包后，向服务器发送第三个包，SYN=0, ACK=1，接收顺序号ACK = Y+1,发送顺序号seq=X+1。此包发送完毕，客户端和服务器进入ESTABLISHED建立成功状态，完成三次握手。

> 四次挥手：  
> 第一次挥手：主动关闭方发送第一个包，其中FIN标志位为1，发送顺序号seq为X。  
> 第二次挥手：被动关闭方收到FIN包后发送第二个包，其中发送顺序号seq为Z，接收顺序号ack为X+1。  
> 第三次挥手：被动关闭方再发送第三个包，其中FIN标志位为1，发送顺序号seq为Y，接收顺序号ack为X。  
> 第四次挥手：主动关闭方发送第四个包，其中发送顺序号为X，接收顺序号为Y。至此，完成四次挥手。

# 51.断开连接的时候客户端为什么需要的等待2MSL时间？ #

> 为了保证客户端发送的最后一个ACK报文能够到达服务器。因为这个ACK报文可能丢失，站在服务器的角度看来，我已经发送FIN+ACK报文请求断开了，客户端还没有给我回应，应该是我发送的请求断开报文它没有收到，于是服务器会重新发送一次，而客户端就能在这个2MSL时间段内收到这个重传的报文，接着再次给出回应报文，并且会重启2MSL计时器。

# 52.servlet是单线程还是多线程？是单例的吗？ #

> servlet单实例多线程

# 53.请说下servlet的生命周期？ #

> Servlet 生命周期可以分成四个阶段：出生（加载和实例化）、初始化、服务、死亡（销毁）。  
> ①出生  
> 当客户第一次请求时，首先判断是否存在 Servlet 对象，若不存在，则由服务器调用无参构造方法创建对象。  
> ②初始化  
> 创建完对象之后就会调用init()方法对其进行初始化。此初始化方法在整个 Servlet 生命周期中只调用一次。  
> ③服务  
> 完成 Servlet 对象的创建和初始化之后，服务器会调用 Servlet 对象的 service()方法来处理客户端的请求。  
> ④死亡  
> 当 服务器关闭或者Servlet 对象要从容器中被删除时，会自动调用 destory()方法。

如果想详解学习请参考本博主的这篇博客：[不会吧！不会吧！Servlet的生命周期，你才知道！  
][Servlet_]

# 54.get请求与post的请求的区别是什么？ #

> get：  
> 1，参数拼接在url，不安全  
> 2，只能是字符串类型  
> 3，大小有限制2kb，速度快  
> post:  
> 1，参数封装到请求体，安全  
> 2，还可以是非字符串类型比如文件  
> 3，理论上大小没限制，速度慢

# 55.请求转发跟请求重定向的区别是什么？ #

> ①请求转发地址栏不会变化，重定向会发生变化。  
> ②请求转发是一次请求、一次响应，速度快，重定向是两次请求、两次响应，速度慢。  
> ③请求转发是请求request的API，重定向是响应response的API。  
> ④请求转发只能在本网站内部，重定向可以定向到任何网站。  
> ⑤请求转发可以进行值传递，重定向不可以。

如果想详解学习请参考本博主的这篇博客：[Servlet中请求转发和重定向的区别，看这一篇就够了！  
][Servlet_ 1]

# 56.JSP是服务器端页面还是客户端页面？ #

> 服务器端页面

# 57.jsp的本质是一个servlet？ #

> 是，在Tomcat运行中，会自动把jsp文件编译为java文件，j继承了HttpServlet。

# 58.静态包含（指令）跟动态包含（动作）有什么区别 #

> 原理不同：  
> 静态包含：先合并再翻译  
> 动态包含：先翻译在包含  
> 最终编译成java文件的数目不同。  
> 静态包含在转换成为java文件的时候将包含文件的内容“复制”到主体文件，然后作为一个整体编译。最终编译为一个java文件。  
> 静态包含在两个文件中不能有相同的变量，动态包含允许  
> 语法不同：  
> 静态包含语法： <%@inclue file=“被包含的页面”%>  
> 动态包含语法：　<jsp:include page=“被包含的页面”>  
> 参数传递不同 :  
> 静态包含不能向被包含页面传递参数  
> 动态包含可以使用jsp:param标签向被包含页面传递参数

# 59.JSP的9大内置对象？ #

> 1.request：HttpServletRequest对象，代表请求  
> 2.response：HttpServletResponse对象，代表响应  
> 3.out：JspWriter对象，代表输出  
> 4.session：HttpSession对象，代表每个会话  
> 5.application：ServletContext应用对象，代表整个应用程序  
> 6.config：ServletConfig配置对象，代表配置文件中的信息  
> 7.pageContext：PageContext对象页面上下文对象，包含页面信息  
> 8.page：当前页面对象（this）（基本不使用）  
> 9.exception：Throwable异常对象，包含jsp异常信息

# 60.会话跟踪的几种技术？ #

> 使用Cookie、URL 重写、隐藏的表单域、HttpSession

[Link 1]: https://blog.csdn.net/weixin_46460843/article/details/109705524
[equals]: https://blog.csdn.net/weixin_46460843/article/details/110310604
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70]: /images/20221120/bb5c8fda30ae4f26867083961fa277ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70 1]: /images/20221120/603682cf68c642669303b2e3cf9e5fdb.png
[Servlet_]: https://blog.csdn.net/weixin_46460843/article/details/110495983
[Servlet_ 1]: https://blog.csdn.net/weixin_46460843/article/details/110693097