Java基础面试题

1: Arraylist和Linkedlist的区别?

  ArrayList

1）ArrayList底层数组结构，原理：数组复制

2）底层自动扩容数组，初始为10，每次扩容上次的1/2

3）善于查询

4）利用index按顺序存储

LinkedList

1）底层链表结构（双链表）

2）善于插入删除数据

3）特殊方法：addLast（），addFirst（），removeFirst（），remove（）删除第一个；removeLast（）

总结：ArrayList更适合读取数据，linkedList更多的时候添加或删除数据。

ArrayList内部是使用可増长数组实现的，所以是用get和set方法是花费常数时间的，但是如果插入元素和删除元素，除非插入和删除的位置都在表末尾，否则代码开销会很大，因为里面需要数组的移动。
LinkedList是使用双链表实现的，所以get会非常消耗资源，除非位置离头部很近。但是插入和删除元素花费常数时间。

2:重载与重写有什么区别?

重写：不同类中，方法体结构相同，逻辑代码可以不同，方法被定义为final不能被重写。

重载：同一类中，方法体结构相同参数列表类型和个数不能相同。

3: &和&&有什么区别?

&和&&都可以作逻辑与，&它的左边无论是true还是false，右边的条件都要进行判断，&&它的左边如果是false，右边则不用进行判断。

&可以用作位运算符，将左边和右边两个数转换成二进制数然后进行与运算。

 

4:接口和抽象类有什么区别?

抽象类特点：

1）不能被实例化（子类继承后可实例化子类）

2）充当父类

3）有属性，方法，构造方法，抽象方法

4）抽象类中抽象方法必须被重写

5）子类有且只有一个父类

   接口特点：

1）不能被实例化

2）充当父接口

3）有属性，抽象方法（属性必须初始化，且不能更改）

4）子类可以实现多个接口

抽象类（abstract class）：
1：abstract 关键字修饰，并且没有方法体
2：抽象类不能直接创建实例
3：抽象类只能被继承，一个具体类继承一个抽象类，必须实现所有抽象方法
接口（interface）：
1：实现接口的一定要实现接口里定义的所有方法
2：接口可以实现多重继承
区别：
1：抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用
2：一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类
3：接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法
4：抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的
5：抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法

6.接口可以继承接口，甚至可以继承多个接口；类可以实现多个接口，只能继承一个类。

 

5:写出JDBC操作数据库的步骤?
1：加载驱动
 Class.forName("com.mysql.jdbc.Driver");
2：创建连接
Connection con = DriverManager.getConnection ("url", "1111", "1111");
3：创建语句
PreparedStatement ps = con.prepareStatement("select * from user");
4：执行语句
ResultSet rs = ps.executeQuery();
5：处理结果
   while(rs.next()) {
       rs.get.....（“”）；
   }
6：关闭资源
   finally {
       if(con != null) {
           try {
               con.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
   }

加载驱动-创建连接-创建语句-执行语句-处理结果-关闭资源

6: HashTable和HashMap有什么区别?

1. HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口
2.主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高Hashtable
3.HashMap允许将null作为一个entry的key或者value，而Hashtable不允许
4.最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是

   HashMap线程不安全。HashMap是map接口的子接口，是将键映射到值的对象，其中键和值都是对象，并且不能包含重复键，但可以包含重复值。HashMap允许包含空键和空值，而HashTable不允许空键值。

   HashTable线程安全。HashMap是HashTable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空键值，由于非线程安全，所以效率上可能高于HashTable。

 

7;创建多线程的方式有几种?分别是什么?线程死锁是如何产生的?如何防止线程死锁现象?

方式：继承Thread、实现 Runnable 接口
产生:
   - 一个资源每次只能被一个进程使用
   - 一个进程因请求发生阻塞时，依然对已获得的资源保持不放
   - 进程已经获得资源使用权，但是一直未使用
   - 同一个进程，频繁的获取资源的优先使用权，一直未释放
防止：
   加锁顺序（线程按照一定的顺序加锁）
   加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该

锁的请求，并释放自己占有的锁）
   死锁检测（一般是将所有的锁存放于map对象中，检测map中的锁）

 

8: String,StringBuffer, StringBuilder 的区别?

1.运行速度快慢为：StringBuilder > StringBuffer > String
   - （String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的）
  2.StringBuilder是线程不安全的，而String、StringBuffer是线程安全的

 

9: TCP和UDP的区别?哪个是三次握手协议?

TCP稳定性较高，但效率低。TCP三次握手协议。
UDP通讯相反，效率较高，但稳定性较差

 

10: JSP的常用指令有哪些?

三个编译指令为：page、include、taglib
七个动作指令为：jsp:forward、jsp:param、jsp:include、jsp:plugin、

jsp:useBean、jsp:setProperty、jsp:getProperty

 

11: DI有几种方式、分别是什么，你常用的是哪种方式?

1：Setter方法
2：构造器
3：接口注入  注解实现注入(常用)

 

12; Mybatis中$和#在xm1中取值有什么不同?

1.mybatis 为我们提供了两种支持动态 sql 的语法：#{} 以及 ${}
2.#方式能够很大程度防止sql注入，$方式无法防止Sql注入
3.$方式一般用于传入数据库对象，例如传入表名
4.＃{}将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号
5.一般能用#的就别用$

 

13: Session和Cookie有什么区别?

Cookie和session做状态管理

Cookie存在客户端、session数据放在服务器上
cookie不是很安全，别人可以分析存放在本地的COOKIE并进行修改
session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器

的性能
单个cookie在客户端的限制是3K，就是说一个站点在客户端存放的COOKIE

不能大于3K

 

14: GET和POST请求的区别?

GET：
   1：从服务器上获取数据，一般不能使用在写操作接口
   2：由URL所限制，GET方式传输的数据大小有所限制，传送的数据量不超过2KB
   3：请求的数据会附加在URL之后，以？分隔URL和传输数据，多个参数用&连接
   4：安全性差
POST:
   1：向服务器提交数据,一般处理写业务
   2：POST方式传送的数据量比较大，一般被默认为没有限制
   3：安全性高
   4：请的求的数据内容放置在HTML HEADER中

 

15:转发(forward) 和重定向(redirect)的区别?

1：效率上
   转发（forward） > 重定向（redirect）
  2：显示上
   重定向（redirect）：显示新的URL
   转发（forward）：地址栏不变
  3：数据上
   转发（forward）：可以共享request里面的数据
   重定向（redirect）：不能
  4：请求次数
   重定向（redirect）是两次
   转发（forward）是一次

 

16: Hibernate与Mybatis区别?

1：hibernate的扩展性和移植性比mybatis强
2：hibernate不需要写sql语句，会自动生成，而mybatis则需要写sql

语句
3：hibernate支持事务、一级缓存、二级缓存、查询缓存等
4：hibernate自己提供分页功能，mybatis需要配置分页插件

 

17: 列举struts2常见的组件有哪些?常见的配置标签有哪些?返回值类型有哪些?

组件：
   strutsParperAndExecuteFilter
   Action
   Result
   Interceptor
标签：
   package
   action
   result
   param
   interceptor
返回值类型：
   dispatcher
   redirect
   redirectAction
   stream
   json

 

18: 用最有效率的方法算出2乘以8等于多少?

2 << 3

 

19: Spring常见的注解有哪些?

@Autowired--自动装配
@Component--自动支持自动装配
@Repository--DAO层实现
@Service--Service层实现
@Controller--Web层实现

 

28: Debug模式下，快捷键有哪些，分别代表什么?

F5：进入方法内
F6：执行下一步
F7：跳出方法外
F8：执行到下一个断点

 

21: Tomcat如何修改端口号，如何清除项目缓存，默认并发量是多少?

端口：server.xml
项目缓存：删除work文件夹下的文件
并发：150-200

 

22: final, finally, finalize的区别?

final—修饰符（关键字）
   如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。
   一个类不能既被声明为 abstract的，又被声明为final的，被声明为final的方法也同样只能使用，不能重载
   finally—异常处理时提供 finally 块来执行操作
   finally块则是无论异常是否发生，都会执行finally块的内容
   finalize—方法名
   finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的，它是在object类中定义的，所有的类都继承了它

 

23:一个汉字几个字节，一个char类型的变量，可以储存一个汉字吗，为什么可以或者不可以?

两个字节，可以存储，前提是汉字必须是Unicode编码

 

24:谈谈Spring AOP的原理?

AOP称为面向切面编程
用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存

等等实现AOP功能关键是采用代理技术，主要分为静态代理(AspectJ)和动态代

理，JDK中采用Proxy类产生动态代理的方式为某个接口生成实现类，如果要

为某个类生成子类，则可以用CGLIB。

 

25:简要说明SSH框架搭建步骤?

1：Struts2
   - 导包
   - 加载struts.xml
   - 配置web.xml
       - filter
   2：Struts2+Spring
   - 导中间包、Spring包
   - 增加Spring的配置文件Applicationcontext.xml
   - 配置web.xml
       - context和监听
   3：Hibernate
   - 导包
   - 增加hibernate的配置文件hibernate.hbm.cfg和表的映射文件
       - 配置数据库的方言和连接、加载映射文件
   4：Hibernate+Spring
   - 导中间包
   - 在spring的配置文件中加载hibernate的配置信息

26:简要说明SSM框架搭建步骤?

1: Spring
   - 导包
   - 增加Spring的配置文件Applicationcontext.xml
   - 配置web.xml
  2：springMVC
   - 导包
   - 增加springMVC的配置文件context-dispatcher.xml
   - 配置web.xml
  3：mybatis
   - 导包
   - 增加mybatis的配置文件mybatis-config.xml
   - 将mybatis的配置文件在spring和springMVC中进行引用和配置

 

27:多线程中run和start方法有什么区别?

Thread的start才是正在开启线程;Run只是调用了一个普通方法，并没有启动另一个线程，程序还是会按照顺序执行相应的代码。Start则表示，重新开启一个线程，不必等待其他线程运行完，只要得到cup就可以运行该线程。

 

28:静态变量和实例变量有什么区别?

静态变量前面要加static，实例变量不用。实例变量属于对象的属性，必须创建了实例对象，才可以被使用，静态变量不属于某个实例对象，而是属于类，也叫类变量，不用创建任何实例对象就会被使用。

29:前后台数据交互的方式有哪些?

json、file、xml、jsonp等

 

30:字节流和字符流有什么区别?

字节流：按字节读写
字符流：按字符
通常在处理文本时优先使用字符流，其他的用字节流

字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符

流在操作时使用了缓冲区，通过缓冲区再操作文件

 

31: Redis支持哪些数据类型的存储?

string、list、set、zset、hash

 

32: Java如何调用Redis进行数据操作，并列举增删改查操作?

1. 导包

2. Jedis jd = new Jedis(IP);

3. jd.ping();//PONG

 

33: Nosql主要支持哪两种数据存储系统?

key-value---Redis
文档存储-----MongoDB

 

34: MongoDB的体系逻辑结构，主要有什么组成?

文档(document)、集合(collection)、数据库(database)

 

35: Redis和MongoDB分别应用于哪些应用场景?

Redis：数据量较小的更性能操作和运算上

MongoDB:主要解决海量数据的访问效率问题

 

36: Java如何链接MongoDB,写出逻辑代码?

导包

//建立连接
MongoClient mc =  new MongoClient("192.168.168.220", 27017); MongoDatabase db = mc.getDatabase("db1");//数据库名称

 

37:如何给张表增加一个字段，写出sq1语句?

alter table 表名 add 字段 类型 NOT NULL Default 0;

 

38: ==与equals有什么区别?

==：比较两个数据内存地址是否相同

equals：比较两个数据值是否一样

 

39: ++i与i++的区别?

++i:先赋值，后运算

i++：先运算，后赋值

 

40: List和Map有什么区别?

list：
   - 链表
   - 有序
   - 继承Collection(set也是)
   - 可以有重复的对象值，但是对象下标不能重复
   Map：
   - key-value
   - 无序
   - 键不能有重复的 值可以用

 

41: Integer与int的区别?

int 是基本数据类型，初值为0。Integer是int的包装类，初值为null
Integer缓存：注意拆箱和装箱（-128-127之间）
原始类型：boolean，char，byte，short，int，long，float，double
包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

 

42:分别写出oracle、mysq1的分页关键词?

oracle：rownum关键词、row_number()函数
mysql：limit 0,5    /    limit 5;

 

43:谈谈你对MVC的理解?

MVC：是一个框架设计模式，其中M（模型）、V（视图）、C（控制器）
视图：视图向用户显示相关的数据，并接受用户的输入。视图不进行任何业

务逻辑处理。如：jsp、html等
模型：表示业务数据和业务处理。属于数据模型，如:entity、jdbc、

hibernate、mybatis等
控制器：接收、响应用户请求，servlet、action、controller等

 

44、如果equals方法比较为true,那么它们的Hashcode值一定相同吗?如果hashcode相同，那么equals方法比较一定为true吗?

不一定相同；一定

 

45:简述servlet生命周期?

通过调用 init () 方法进行初始化；调用 service() 方法来处理客户端的请求；通过调用 destroy() 方法终止（结束）Servlet 是由 JVM 的垃圾回收器进行垃圾回收的；

 

46:进程和线程的区别是什么?

- 进程是资源的分配和调度的一个独立单元，而线程是CPU调度的基本单元
- 同一个进程中可以包括多个线程
- 进程结束后它拥有的所有线程都将销毁，而线程的结束不会影响同个进程中的其他线程的结束
- 线程共享整个进程的资源（寄存器、堆栈、上下文），一个进行至少包括一个线程
- 进程的创建调用fork或者vfork，而线程的创建调用pthread_create
- 线程中执行时一般都要进行同步和互斥，因为他们共享同一进程的所有资源

 

47:进程的几种状态分别是什么?

就绪状态：
   当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态称为就绪状态。
运行状态：
   当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为运行状态。
阻塞状态：
  正在运行的进程，由于等待某个事件发生而无法执行时，便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种，例如，等待I/O完成、申请缓冲区不能满足、等待信件(信号)等。
状态转换：
   就绪→运行：处于就绪状态的进程，当进程调度程序为之分配了处理机后，该进程便由就绪状态转变成运行状态。
   运行→就绪：处于运行状态的进程在其运行过程中，因分配给它的一个时间片已用完而不得不让出处理机，于是进程从运行状态转变成就绪状态。
   运行→阻塞：正在运行的进程因等待某种事件发生而无法继续运行时，便从运行状态变成阻塞状态。
   阻塞→就绪：处于阻塞状态的进程，若其等待的事件已经发生，于是进程由阻塞状态转变为就绪状态。

 

48: JDK和JRE的关系区别是什么?

JDK是Java的开发工具，JDK包含JRE。
JRE只是Java程序的运行环境，它最核心的内容就是JVM（Java虚拟机）

及核心类库。

 

49: SpringMVC运行原理是什么?

1. 客户端请求提交到DispatcherServlet
   2.由DispatcherServlet控制器查询一个或多个HandlerMapping，找到

处理请求的Controller
3.DispatcherServlet将请求提交到Controller
4.Controller调用业务逻辑处理后，返回ModelAndView
5.DispatcherServlet查询一个或多个ViewResoler视图解析器，找到

ModelAndView指定的视图
6.视图负责将结果显示到客户端
DispatcherServlet是整个Spring MVC的核心。它负责接收HTTP请求

组织协调Spring MVC的各个组成部分

 

50：用户在浏览器中输入URL之后，发什么了什么?写出请求和响应的流程

1：域名解析
2：TCP三次握手
3：浏览器向服务器发送http请求
4：浏览器发送请求头信息
5：服务器处理请求
6：服务器做出应答
7：服务器发送应答头信息
8：服务器发送数据
9：TCP连接关闭

 

51:响应结果状态码有哪些，并给出中文含义?

    1**：信息性状态码
2**：成功状态码
   200：请求正常成功
   204：指示请求成功但没有返回新信息
   206：指示服务器已完成对资源的部分 GET 请求
3**：重定向状态码
   301：永久性重定向
   302：临时性重定向
   304：服务器端允许请求访问资源，但未满足条件
4**：客户端错误状态码
   400：请求报文中存在语法错误
   401：发送的请求需要有通过HTTP认证的认证信息
   403：对请求资源的访问被服务器拒绝了
   404：服务器上无法找到请求的资源
5**：服务器错误状态码
   500：服务器端在执行请求时发生了错误
   503：服务器暂时处于超负载或正在进行停机维护，现在无法处理请求

 

52: 什么是ORM?

对象关系映射（Object Relational Mapping，简称ORM）
为了解决面向对象与关系数据库存在的互不匹配的现象的技术，ORM是通过使用描述对象和数据库之间映射的元数据(元数据一般采用XML格式)，将程序中的对象自动持久化到关系数据库中，Java典型的ORM中间件有:Hibernate,ibatis,speedframework,mybatis

 

53:什么是IOC?

(Inversion of Control,简称IOC)，即控制反转，是一种设计模式，是spring的核心。可以解决代码耦合，由IOC容器来管理对象的生命周期、依赖关系等。

 

54:jsp的作用域有哪些?

page：当前页面有效
request：一次会话请求有效
session：浏览器进程，只要浏览器不关闭，则一直有效
application：服务器只要运行，则有效

 

55: sleep和wait 有什么区别?

sleep：
   1：属于Thread类，表示让一个线程进入睡眠状态，等待一定的时间之后，自动醒来进入到可运行状态，不会马上进入运行状态
   2：sleep方法没有释放锁
   3：sleep必须捕获异常
wait：
   1：属于Object，一旦一个对象调用了wait方法，必须要采用notify()和notifyAll()方法唤醒该进程
   2：wait方法释放了锁
   3：wait不需要捕获异常

 

56: Java 中的final关键字有哪些用法?

1：修饰类：表示该类不能被继承
2：修饰方法：表示方法不能被重写
3：修饰变量：表示变量只能一次赋值以后值不能被修改（常量）

 

57: Error和Exception有什么区别?什么时候需要捕获异常，什么时候需要抛出异常?

1:Error表示系统级的错误和程序不必处理的异常,有可能恢复，但是恢复比较困难的严重问题。
2：Exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况
异常处理的原则：
   1：System.out.println是高代价的。调用System.out.println会降低系统吞吐量
   2：在生产环境中别用异常的printStackTrace()方法。
   3：如果你不能处理异常，不要捕获该异常
   4：如果要捕获，应在离异常源近的地方捕获它
   5：捕获的异常一定要做处理
   6：可以自定义异常
   7：就近原则

 

58:写出冒泡排序的程序代码?

 

59:数据库集群模式下，如何保证主从数据库的数据一致性?

以mysq1数据库为例进行说明配置步骤？

1：开启所有服务器的二进制文件
2：开启所有从服务的IO和SQL线程
3：配置主从连接的用户信息和主从信息
4：开启3306端口号

 

60: 简述JAVA中I/O和NIO的区别?

NIO:是一种new IO，其目的是为了实现高速IO的代码，将IO操作并转换为操作系统，属于非阻塞型，java.nio.*，是以块（缓冲区）的形式就行数据的传输。
IO：是以流的方式就行数据的传输，属于阻塞型，影响程序的性能
传统阻塞IO，如果你要read/write( byte[10M])一个10M的文件，一旦调用了read/write( byte[10M])这个方法，就得等10M全部read/write，方法底层才会返回。
非阻塞线程，调用read/write( byte[10M])方法立即返回，当然这并不能代表10M已经read/write完成，你需要检测这个byte[10M]的缓冲区。

 

61:简述单例模式的特征和应用场景?

单例模式（Singleton），也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。
单例模式只允许创建一个对象，因此节省内存，加快对象访问速度
单例模式要素：
   a.私有构造方法
   b.私有静态引用指向自己实例
   c.以自己实例为返回值的公有静态方法
饿汉式：单例实例在类装载时就构建，急切初始化。（预先加载法）
   优点
       1.线程安全
       2.在类加载的同时已经创建好一个静态对象，调用时反应速度快缺点
        资源效率不高，可能getInstance()永远不会执行到，但执行该类的其他静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化
懒汉式：单例实例在第一次被使用时构建，延迟初始化。
应用场景：
   - 需要频繁实例化然后销毁的对象
   - 创建对象时耗时过多或者耗资源过多，但又经常用到的对象
   - 有状态的工具类对象
   - 频繁访问数据库或文件的对象
   - 网站计数器，一般是采用单例模式实现
   - 由于配置文件一般都是共享资源，即web应用的配置对象的读取，一般采用单例模式来实现。如：spring的配置文件的读取等
   - 多线程的线程池的设计一般也是采用单例模式
   - 数据库连接池的设计

 

62:写出将1000个存在重复手机号的号码池去重的JAVA代码?

 

63:Java接口的修饰符有哪些?

public、final、abstract

 

64:Java支持的数据类型有哪些?什么是自动拆装

8种基本数据类型：
   byte      8位         取值范围  -2^7 ~ 2^7 -1
   short     16位        取值范围  -2^15 ~ 2^15 - 1
   char      16位        取值范围  0 ~ 2 ^16 - 1
   boolean   位数不明确   取值范围  true false
   int       32位        取值范围  -2^31 ~ 2^31 - 1
   long      64位        取值范围  -2^63 ~ 2^ 63 - 1
   float     32位        取值范围  1.4e-45 ~ 3.40e38
   double    64位        取值范围  4.9e-324 ~ 1.79e308
注意：
   需要注意的是，String不是基本数据类型，而是引用类型
在jdk1.5中引入了自动拆装箱的新特性，自动拆装箱，是指基本数据类型和引用数据类型之间的自动转换
   基本类型转换成包装类型，称为装箱  
   Integer intObjct = new Integer(2); //装箱
   //Integer intObjct = 2 //自动装箱  
   //自动装箱，如果一个基本类型值出现在需要对象的环境中，会自动装箱  
   如Integer 和 int 可以自动转换； Float和float可以自动转换

 

65:Math.round(11.5)等于多少? Math.round(-11.5)等于多少?

round方法，他表示“四舍五入”，算法为Math.floor(x+0.5),即将原来的数字加上0.5后再向下取整
12、-11

 

66:写一单实例类要求精简，清晰? (单例抛式)

饿汉式单例：
   public class Singleton {
       private Singleton(){}
       private static Singleton instance = new Singleton();
       public static Singleton getInstance(){
           return instance;
       }
   }
懒汉式单例：
   public class Singleton {
       private static Singleton instance = null;
       private Singleton() {}
       public static synchronized Singleton getInstance(){
           if (instance == null)
               instance ＝ new Singleton();
           return instance;
       }
   }

 

67:构造器(constructor)是否可被重写(override)是否可被重载?是否可被继承？

构造器不能被继承，因此不能重写Override，但可以被重载Overload

 

68:JSP和Servlet有哪些相同点和不同点，他们之间的联系是什么？

- jsp本质就是servlet
- jsp应用于页面显示，servlet应用于逻辑控制
- setvlet中没有内置对象，jsp中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象及HttpServlet对象得到

 

69:简述synchronized和java.util.concurrent.locks.Lock的异同？

- Lock能完成几乎所有synchronized的功能，并有一些后者不具备的功能，如锁投票、定时锁等候、可中断锁等候等
- synchronized 是Java内置的关键字，Lock 则是JDK 5中出现的一个包
- synchronized 同步的代码块可以由JVM自动释放；Lock 需要程序员在finally块中手工释放

 

70:解析xml和exce1分别使用什么技术?

xml-dom4j
excel-poi、jxl

 

71:如何发布spring boot项目，简述步骤?

发布JAR包、发布WAR包、部署到自动化容器中

 

72:什么是java序列化，如何实现java序列化?

概念：
   序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化（将对象转换成二进制）。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题
序列化：把Java对象转换为字节序列的过程。
反序列化：把字节序列恢复为Java对象的过程。
实现：
   将需要被序列化的类实现Serializable接口
注意：
   被关键字static、transient修饰的变量不能被序列化。在被序列化后，transient修饰的变量会被设为初始值。如int型的是0、对象型的是null.

 

73:在JAVA中，如何跳出当前的多重嵌套循环?

用break; return 方法。

 

74:面向对象的特征有哪些方面?

- 抽象：
   抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
- 继承：
   继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
- 封装：
   封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
- 多态性：
   多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

 

75: Collection和Collections的区别?

Collection是集合类的上级接口
继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

 

76:同步和异步有何异同，在什么情况下分别使用他们?举例说明？

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率

77:abstract class和interface有什么区别?

78:GC是什么?为什么要有GC?

GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，
Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法

 

 

79:请说出你所知道的线程同步的方法?

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。 notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

 

80:JSP的内置对象及方法?

request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法。
response表示HttpServletResponse对象，并提供了几个用于设置送回 浏览器的响应的方法（如cookies,头信息等）
out对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。
pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的API，并且包装了通用的servlet相关功能的方法。 session表示一个请求的javax.servlet.http.HttpSession对象。
Session可以存贮用户的状态信息 applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息 config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。
page表示从该页面产生的一个servlet实例

 

 

81:如何现实servlet的单线程模式?

<%@ page isThreadSafe=”false”%>

 

82:面间对象传递的方法?

request，session，application，cookie等

 

83:Request对象的主要方法?

setAttribute(String name,Object)：设置名字为name的request的参数值
getAttribute(String name)：返回由name指定的属性值
getAttributeNames()：返回request对象所有属性的名字集合，结果是一个枚举的实例
getCookies()：返回客户端的所有Cookie对象，结果是一个Cookie数组
getCharacterEncoding()：返回请求中的字符编码方式
getContentLength()：返回请求的Body的长度
getHeader(String name)：获得HTTP协议定义的文件头信息
getHeaders(String name)：返回指定名字的request Header的所有值，结果是一个枚举的实例
getHeaderNames()：返回所以request Header的名字，结果是一个枚举的实例
getInputStream()：返回请求的输入流，用于获得请求中的数据 getMethod()：获得客户端向服务器端传送数据的方法
getParameter(String name)：获得客户端传送给服务器端的有name指定的参数值
getParameterNames()：获得客户端传送给服务器端的所有参数的名字，结果是一个枚举的实例
getParameterValues(String name)：获得有name指定的参数的所有值
getProtocol()：获取客户端向服务器端传送数据所依据的协议名称
getQueryString()：获得查询字符串
getRequestURI()：获取发出请求字符串的客户端地址
getRemoteAddr()：获取客户端的IP地址
getRemoteHost()：获取客户端的名字
getSession([Boolean create])：返回和请求相关
Session getServerName()：获取服务器的名字
getServletPath()：获取客户端所请求的脚本文件的路径
getServerPort()：获取服务器的端口号
removeAttribute(String name)：删除请求中的一个属性

 

84:J2ee常用的设计模式?说明工厂模式?

Java中的23种设计模式：
Factory（工厂模式）， Builder（建造模式），
Factory Method（工厂方法模式）， Prototype（原始模型模式），Singleton（单例模式）， Facade（门面模式），
Adapter（适配器模式）， Bridge（桥梁模式），
Composite（合成模式）， Decorator（装饰模式），
Flyweight（享元模式）， Proxy（代理模式），
Command（命令模式）， Interpreter（解释器模式），
Visitor（访问者模式）， Iterator（迭代子模式），
Mediator（调停者模式）， Memento（备忘录模式），
Observer（观察者模式）， State（状态模式），
Strategy（策略模式）， Template Method（模板方法模式），
Chain Of Responsibleity（责任链模式）
工厂模式：工厂模式是一种经常被使用到的模式，
根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，
通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。
首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。
然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。
当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

 

85:List、Map、Set三个接口，存取元素时，各有什么特点?

List 以特定次序来持有元素，可有重复元素。
Set 无法拥有重复元素,内部排序。
Map 保存key-value值，value可多值。

 

86:如何对数据库做优化?

1：数据库设计
   数据库表：字段类型、字段长度、注释、字段命名规范
   数据库索引：外键、关联字段、查询频率比较高的字段、
           如果数据表字段>20，则最多支持16个索引
           如果数据表字段<20，则根据查询频率字段来定
   数据库视图：相当于一张临时表，业务中，尽量少使用
   数据库引擎：根据业务，选择对应的表引擎技术
   数据库存储过程：尽量少用
   数据库字符：UTF-8、或者和页面字符保持一致
   数据库监听器/触发器：一般用于调度任务或者备份还原
2：业务调用的sql语句优化
   xml：
   尽量少关联表，效率最高关联4张表，如果多于4张表，则需要开启两个链接事务，但是这两个事务，必须在一个service当中。
   如果是查询语句，则不建议使用*
   如果是查询语句，where条件后面，最好使用索引字段进行关联
3：数据库服务器的搭建（集群）
   主从配置：
   读写分离：
   自动化（容器）：

 

87:如何对JVM进行性能调优?

 

88:如何实现集群模式下，session共享?

一：Tomcat本身配置
1：登录成功之后，将session信息存放到redis中，利用拦截器来过滤查找session（推荐）
2：配置tomcat文件server.xml
<Engine name="Catalina" defaultHost="localhost" jvmRoute="8081">
<Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>
如果还没有session信息同步，则需要在项目的启动容器web.xml中，在display-name标签下面，添加<distributable/>
二：使用redis服务器

 

89: 程序员如果想换行，应该怎么处理?

回车

90:公司如果想换一个灯泡，请问需要几个java工程师?

 

91: Hibernate一级缓存和二级缓存的区别?

1、  一级缓存是session独享，默认开启，无需配置

2、  二级缓存是session共享，需要在配置文件中开启，可以指定缓存区域块

92: Hibernate有几种查询方式?

HQL语句查询、Criteria查询、NativeSQL查询

93、解释内存中的栈(stack)、堆(heap)和方法区(method area)的用法。
答：通常我们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用JVM中的栈空间；而通过new关键字和构造器创建的对象则放在堆空间，堆是垃圾收集器管理的主要区域，由于现在的垃圾收集器都采用分代收集算法，所以堆空间还可以细分为新生代和老生代，再具体一点可以分为Eden、Survivor（又可分为From Survivor和To Survivor）、Tenured；方法区和堆都是各个线程共享的内存区域，用于存储已经被JVM加载的类信息、常量、静态变量、JIT编译器编译后的代码等数据；程序中的字面量（literal）如直接书写的100、"hello"和常量都是放在常量池中，常量池是方法区的一部分，。栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过JVM的启动参数来进行调整，栈空间用光了会引发StackOverflowError，而堆和常量池空间不足则会引发OutOfMemoryError。

1、下列说法正确的是(  )

A、java的数组可以随时改变大小

B、String字符串的长度和大小都是不可变的

C、boolean类型变量默认初始值为true（false）

D、Java虚拟机是实现跨平台的基础

 

2、下面代码运行结果为:( A )

      public static void main(String[] args){

     int  x = 1, y = 1, z = 1;

     if(x--==1&&y++==1  ||z++= =1) {

 System.out.println(“x=”+x+”,y=”+y+”,z=”+z;);

              }

}

   A: x=0,y=2,z=1                        B: x=1,y=2,z=1

   C: 没有输出                D:x=0,y=2,z=2

 

3、下列没有语法编译错误的是：(   )

A.  public static void main(String[] args){

  byte  b1 =  1;

         byte  b2 =  2;

      byte  b =  b1+b2;

  }

B.  public static void main(String[] args){    

         int n = 100;

       while(n>0){

System.out.println(n);

   }

   }

C.  public static void main(String[] args){    

 int n;

        for(int i = 0;i<10;i++){

    n+= i ;

         }

}

        D.  public static void main(String[] args){          

int n = 100;

        for(;;){

           }

        System.out.println(n);

   } 

 

4、以下程序的输出结果为（C）

public  class  Test{

public  static  void  main (String[] args){

int[]  a = {1,2,3,4,5};

int[]  b = change(a);

b[1]  = 7;

System.out.println(a[1]);

}

public  static  int[]  change(int[]  a){

a[1] = 6;

return  a ;

}

}

A、编译错误    B、运行出错   C、6   D、7

 

5、对于构造函数,下列叙述不正确的是（C）

A、构造函数是类的特殊函数，他的方法名必须与类名相同

B、构造函数没有返回值类型

C、一个类可以有多个构造函数

D、构造函数在类加载时调用

 

6、给定java代码如下：

  class Parent{

      int i=2;

      public Parent() {

           System.out.println("parent");

      }

}

class Child extends Parent{

      int i=5;

      public Child() {

           System.out.println("child");

      }

}

public class Test {

      public static void main(String[] args) {

           Parent p = new Child();

           System.out.println(p.i);

      }

}

   运行编译后，输出结果为(    )

   A. child 2       B. child 5   C.parent child 2   D.parent child 5

7、以下程序的输出结果为：（）

class  ClassA{

int  value;

}

public  class  TestClassA{

public  static  void  main(String[]  args){

int  value = 10;

changeInt(value); 

System.out.println(value); 

 

ClassA  ca = new  ClassA();

ca.value = 10;

changeObject(ca);

System.out.println(ca.value);

}

public  static  void  changeInt(int  value){

++value;

}

public  static  void  changeObject(ClassA  ca){

ca.value++;

}

}

A.编译不通过         B.10,11          C. 10,10         D. 11,11

 

8、阅读以下代码，能正确删除所有”java”的是: ( B)

public class Test1 {

      public static void main(String[] args) {

           List<String> list = new ArrayList<>();

           list.add("aa");

           list.add("java");

           list.add("bb");

           list.add("java");

           list.add("java");

      }

}

A、     for(int i=0;i<list.size();i++){

           if("java".equals(list.get(i))){

                 list.remove(i);

           }

      }

B、for(int i=list.size()-1;i>=0;i--){

                 if("java".equals(list.get(i))){

                      list.remove(i);

                 }

      }

C、list.remove(“java”);

D、list.removeAll(“java”);

 

9、下面程序的输出结果为( )

public class Test {

      public static String outPut="";

      public static void foo(int i){

           try {

                 if(i==1)

                      throw new Exception();

                 outPut+="1";

           } catch (Exception e) {

                 outPut+="2";

                 return;

           }finally{

                 outPut+="3";

           }

           outPut+="4";

      }

      public static void main(String[] args) {

           foo(0);

           System.out.println(outPut);

           foo(1);

           System.out.println(outPut);

      }

}

A、134  13423    B、1  134    C、134  34    D、134  134134

 

10、下面程序的输出结果为( )

class T1{

      int i=0;

      public void Test1(){

           System.out.println(i);

      }

      public void Test2(){

           System.out.println(i);

      }

}

class T2 extends T1{

      int i=2;

      public void Test2(){

           System.out.println(i);

      }

}

public class TestCase {

      public static void main(String[] args) {

           T1 test = new T2();

           test.Test1();

           test.Test2();

           System.out.println(test.i);

           test = (T2)test;

           System.out.println(test.i);

      }

}

A、0  0  0  0     B、0  2  0  0   C、0  2  2  2     D、编译不能通过 

二、问答题(每题5分,共60分)

1、描述你所理解的java中抽象类和接口的概念

2、简述面向对象的特征以及作用

3、HashMap和HashTable有什么区别,ArrayList和LinkedList?

4、拦截器和过滤器的应用场景是什么,有什么区别

拦截器和过滤器的区别：

1、过滤器是依赖于Servlet容器，拦截器不依赖于容器

2、过滤器是可以拦截所有请求，拦截器只针对Action起作用

3、过滤器只在容器初始化执行一次，拦截器可以多次执行

4、过滤器不能访问值栈中的对象，拦截器可以访问值栈中的对象

5、过滤器底层实现：回调

拦截器底层实现：反射

 

5、如何理解设计模式,用代码写出一种你最熟悉的设计模式

6、cookie和session的作用,区别以及应用场景,分别用图画出工作原理？

cookie和Session

状态管理:

web应用程序是基于HTTP协议的，而HTTP协议是无状态的协议，无状态也就是说一次请求，一次响应之后即断开连接，而同一个用户的下一次请求需要重新建立连接，但在有时候服务器需要判断是否为同一个用户的多次操作，所以这些时候需要将用户的多次请求当做说一个整体来看待，并且将多次交互涉及到的数据进行保存下来

状态：交互产生的数据

管理：多次交互对数据的修改

实现状态常见的有两种方式

cookie：浏览器客户端状态管理，将状态保存在浏览器客户端

session：服务器状态(数据)管理，将状态保存在服务器

Cookie：实现原理

1、浏览器客户端第一次访问服务器端返回响应数据时，响应数据包中以Set-Cookie消息头方式给浏览器返回cookie信息

Set-Cookie：name=张三

Set-Cookie：count =10；

2、浏览器接受服务器端的响应数据包之后，解析响应数据包，获取cookie信息，保存在客户端

3、客户端在后续每一次访问时，需要携带保存cookie，以cookie请求消息头方式发给服务器

cookie：name=张三，count=10

4、服务器接受请求之后，获取请求数据包中cookie信息进行操作，完成HTTP状态管理

Session

1、客户端发送第一次请求，服务器端会创建一个session对象，把相关的数据存储到session中，并给该对象分配一个32位的唯一id，一般称之为JSESSIONID

2、在服务器第一次给客户端返回响应时，把JESSIONID以Set-Cookie消息头方式带回给浏览器客户端

Set-Cookie：JESSIONID=xxxx

3、在客户端接受到响应数据包之后，解析出JESSIONID以cookie形式存储在浏览器客户端

4、在后续浏览器客户端每一次发送请求时，以Cookie消息头方式把JESSIONID发送给服务器

Cookie：JESSIONID=xxxx

5、服务器获取JESSIONID后，根据JESSION去找相应的session 对象，完成状态管理

 

7、什么是MVC,说下你对MVC的理解？

8、struts2和springmvc比较有什么共同点和不同点,分别画出执行流程图

9、什么是IOC和AOP,底层实现原理分别是什么？

IOC：Inversion of Control 控制反转

改变对象的创建方式，由最初的new方式创建对象，转变为由spring容器去创建和管理。降低对象之间的耦合度；IOC是整个spring框架的核心，spring其他所有功能都是基于IOC基础之上完成的。

DI：Denpency Injection 依赖注入

1、DI作用是维护对象之间的关系，将一起工作具有关系的对象通过构造器或者set方法传入值建立关系。

2、IOC是一种思想，DI是实现IOC思想的途径

AOP：Aspect Oriented Programming 面向切面编程

将一个系统中公用的业务逻辑进行提取出来，单独封装成一个组件(切面)，然后再以配置的方式作用到系统中，实现程序的可插拔性，提高代码复用，提升系统性能。

AOP底层实现原理

动态代理模式：可以根据一个类去动态的生成另外一个类，代理类会拥有委托类的API方法。

 

 

10、Hibernate对象有哪些状态,怎么转换

Hibernate对象有三种状态，分为：

1、  临时态：内存中有对象，数据库没有与之对应的数据，新建的对象也是临时状态，持久状态的对象调用了delete()方法也会变成新建状态；

2、  持久态：内存中有对象，数据库有与之对应的数据，修改对象的属性，数据库中数据也会跟着修改。持久状态的对象存在于内存的session缓存区域。

2.1>新建状态调用了save()或者saveOrUpdate()会变成持久状态

2.2>通过id从数据库get()或者load()出来的对象也是持久态的对象

2.3>游离态对象调用了save()或者saveOrUpdate()方法也会变成持久态

3、游离态

内存中有对象，数据库中有之对应的数据，但是对象处于离线状态，修改对象的属性，数据库数据不会修改

11、简述事物隔离级别,传播特性,脏读,幻读,不可重复读分别是什么意思？

事务的特性：

1、  原子性（Atomicity）2、一致性（Consistency）3、隔离性（Isolation）4、持久性（Durability）

事务的隔离级别：事务的隔离级别也分为四种，由低到高依次分别为：read uncommited（读未提交）、read commited（读提交）、read repeatable（读重复）、serializable（序列化），这四个级别可以逐个解决脏读、不可重复读、幻读这几类问题。

1.read uncommited：是最低的事务隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。

2.read commited：保证一个事物提交后才能被另外一个事务读取。另外一个事务不能读取该事物未提交的数据。

3.repeatable read：这种事务隔离级别可以防止脏读，不可重复读。但是可能会出现幻象读。它除了保证一个事务不能被另外一个事务读取未提交的数据之外还避免了以下情况产生（不可重复读）。

4.serializable：这是花费最高代价但最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读之外，还避免了幻象读。

脏读：指当一个事务正字访问数据，并且对数据进行了修改，而这种数据还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。因为这个数据还没有提交那么另外一个事务读取到的这个数据我们称之为脏数据。依据脏数据所做的操作是不正确的。

幻读：一个事务先后读取一个范围的记录，但两次读取的纪录数不同，我们称之为幻象读（两次执行同一条 select 语句会出现不同的结果，第二次读会增加一数据行，并没有说这两次执行是在同一个事务中）

不可重复读：指在一个事务内，多次读同一数据。在这个事务还没有执行结束，另外一个事务也访问该同一数据，那么在第一个事务中的两次读取数据之间，由于第二个事务的修改第一个事务两次读到的数据可能是不一样的，这样就发生了在一个事物内两次连续读到的数据是不一样的，这种情况被称为是不可重复读

Spring事务传播特性：

事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持支持7 种事务传播行为：

propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个，加入到这个事务中，这是最常见的选择

propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。

propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。把当前事务挂起。

propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作类似的操作

Spring 默认的事务传播行为是默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情，它适合于绝大多数的情况。假设 ServiveX#methodX() 都工作在事务环境下（即都被 Spring 事务增强了），假设程序中存在如下的调用链： Service1#method1()->Service2#method2()>Service3#method3()，那么这，那么这 3 个服务类的 3 个方法通过 Spring 的事务传播机制都工作在同一个事务中

12、有哪些方式可以提高数据库的查询效率？

1.建立适当的索引

2.避免在索引上使用计算

3.避免在索引列上使用NOT

4.避免在索引上使用IS NULL 和 IS NOT NULL

5.避免不必要的行和列

6．Select 子句中避免使用 *

7.在IN后面值的列表中，将出现最频繁的值放在最前面，出现最少的放在最后，减少判断次数。

8.使用batch处理

9.注意Union和Union all的区别

10.Where子句中的连接顺序

11.DISTINCT的使用：注意，在数据量大的时候，尽量不要使用，它同UNION一样会使查询变慢。因为Oracle需要对后面的所有字段进行排序，消耗性能。

13、有2个空水壶,容积是5升和6升,怎样才能利用这2个空水壶从水池中取出3升的水？

将6升水倒入5升的，6升剩下1升；把1升水放入到5升壶中，再用6升壶水倒入放有1升水的5升壶，6升壶剩余2升；把这2升水在倒入5升壶，再用6升壶倒入5升壶，6升的壶就剩余3升水；

 

 

 

              SSH、SSM框架测试题

                         --将答案写在答题纸上

1、Struts2的执行流程是什么

struts2执行流程(重点）

1、浏览器向服务器发起请求

2、请求首先会被提交到web.xml中定义的前端过滤器filter中

3、前端过滤器解析请求路径，在根据struts.xml文件中的配置，决定将这个请求交给哪一个action进行处理，并且指定交由哪一个业务方法进行处理

4、业务方法处理完请求之后，会给前端过滤器返回一个字符串

5、前端过滤器拿到字符串之后在根据struts.xml中result配置找到相应的页面然后在进行返回

 

2、值栈和OGNL作用分别是什么？

1、值栈是什么

Struts2中的数据中心，主要存储与当前Action相关的数据和信息

--当前action对象

--action中定义的属性(有set／get方法)

--action中定义的域对象：request，session，application

2、值栈的作用

Action向页面传输值的缓存区

3、值栈到存值区域

root区（list区域）：以栈结构形式存储当前Action中的属性以及直接往栈中push的元素

context区（map区域）：主要存储与当前Action相关的域对象信息

request，session，application

4、OGNL

Struts2中定义的一种表达式语言，主要用于可以从值栈中取值

4.1、引入Struts2的标签库

4.2、从root区域取值

<s:property value="属性名"/>

靠近栈顶到同名会被先取出来，然后就不再往下查询

4.3、从context区域取值

<s:property value="#域对象.key值"/>

3、Struts中JSP如何给Action传值

 

1、在Action中通过ServletActionContext获取到request对象，然后调用request.getParameter("key值")

2、属性注入

2.1、请求参数key值（一般是表单name值），必须和action中定义的属性名保持一致

2.2、action中属性提供set/get方法。

3、域模型传值

针对表单中请求参数较多

3.1、创建一个实体类，根据表单中提交项定义属性，属性要提供set/get方法

3.2、在action中定义一个实体类对象属性，属性提供set/get方法

3.3、表单中的提交项name属性中为action实体对象名.实体类属性名

如：name="user.username"

name="user.password"

 

4、拦截器的作用,以及拦截器和过滤器之间的区别?

Struts2中定义的对Action进行动态拦截的对象，拦截器中的方法会在Action调用前后都会执行，也可以通过动态设置来阻止Action执行。

拦截器的作用：封装代码通用逻辑，以便于重复利用，如：登陆验证，日志记录，权限控制；而且拦截器可以通过动态配置来使用，提供系统灵活性，实现解耦合。

拦截器和过滤器的区别：

1、过滤器是依赖于Servlet容器，拦截器不依赖于容器

2、过滤器是可以拦截所有请求，拦截器只针对Action起作用

3、过滤器只在容器初始化执行一次，拦截器可以多次执行

4、过滤器不能访问值栈中的对象，拦截器可以访问值栈中的对象

5、过滤器底层实现：回调

拦截器底层实现：反射

 

5、IOC是什么,底层如何实现的,IOC与DI之间关系

IOC：Inversion of Control 控制反转；改变对象的创建方式，由最初的new方式创建对象，转变为由spring容器去创建和管理，降低对象之间的耦合度。IOC是整个spring框架的核心，spring其他功能都是基于IOC基础上完成的。

DI:Denpency Injection 依赖注入，DI的作用是维护对象之间的关系，将一起工作具有关系的对象通过构造器或者set方法传入值建立关系。

IOC是一种思想，DI是实现IOC思想的途径

 

6、AOP作用是什么,底层如何实现在哪些地方会用到,分别简述切面切入点和通知

Aspect Oriented Programming 面向切面编程

将一个系统中公用的业务逻辑进行提取出来，单独封装成一个组件(切面)，

然后再以配置的方式作用到系统中，实现程序的可插拔性，提高代码复用，

提升系统性能。

二、AOP底层实现原理

动态代理模式：可以根据一个类去动态的生成另外一个类，代理类会拥有

委托类的API方法。

JDK动态代理(只支持接口注入)

CGLIB动态代理(可以支持普通类注入)

三、AOP和OOP区别

1、AOP是以OOP为基础

2、OOP侧重于对象的封装，AOP侧重于共通业务逻辑的封装

四、AOP使用方式

1、切面：Aspect

系统中共通业务逻辑的封装，会在某个时刻或者阶段共通调用，强调

调用时机相同，如：事务处理，异常处理，日志，安全验证，权限验证

2、切入点：PointCut

切入点目标：给谁追加共通处理

在spring中提供切入点表达式(正则表达式)

1>名称限定表达式(切入到方法)

语法：execution(修饰符？ 返回值类型|* 方法名|*(参数列表|..))

2>类型限定表达式(切入到某一个类)

语法：within(类型)

3、通知advice

什么时候调用共通的业务逻辑

主要用于指定切面作用到切入点上的时机

在spring中提供了五种类型通知

1>前置通知-->目标方法调用前 @Before

2>后置通知-->目标方法调用后 @AfterReturning

3>异常通知-->目标方法产生异常后调用 @AfterThrowing

4>最终通知-->目标方法进行finally调用 @After

5>环绕通知-->目标方法调用前后都会执行 @Around

环绕通知=前置通知+后置通知

 

7、什么是动态代理模式

8、什么是spring容器

在Spring框架中，所有的Java类和JavaBean对象都会被当作是一个bean组件，这些bean组件都是由spring容器负责管理和创建以及维护这些对象之间的关系。

 

9、spring如何管理Bean对象

1、管理对象的实例化(最常用)

构造器构建对象

<bean id="" class=""></bean>

静态工厂构建对象

<bean id="" class="" factory-method=""></bean>

实例工厂构建对象

<bean id="" factory-bean="" factory-method=""></bean>

2、管理对象的作用域

scope="singleton"默认，单例模式，每次调用getBean()返回同一个对象

scope=“prototype”每次调用getBean()返回一个新的对象

3、管理对象的生命周期

init-method=“”bean组件的初始化方法，

在bean组件实例化完成后自动调用，

destroy-method=""bean组件销毁方法，单例bean组件在容器关闭时调用

4、延迟实例化对象

在spring容器中所有的单例bean默认在容器启动时构建对象

lazy-init=“true”将单例对象实例化时机延迟到调用getBean()方法时调用

lazy-init="false"默认值，容器启动构建单例对象

 

10、什么是Restful,如何编写一个Restful风格的springMvC项目

1、Restful

表现层状态转移，是一个软件设计风格，主要是用于对网络上的资源进行统一定位以及规定统一操作的方式

2、网络上的资源(核心)

1>网络上的所有数据都可以抽象为资源，Restful可以对资源进行标识

2>无论以任何方式来操作这个资源都不会影响资源标识

3、Restful优点

1>降低程序复杂性

2>提高程序的可伸缩性

4、SpringMVC对Restful的支持

1>统一规定网络上资源的标识

2>统一规定访问资源的方式

 

5、如何编写Restful风格的SpringMVC应用

1>将前端过滤器中请求路径url-pattern改为/

DispatcherServlet当拦截到请求之后，会将请求拿到映射器中做匹配，匹配上了进入处理器，匹配不上之间返回404，不会去找静态页面

解决问题：将*.do改为/之后，webContent目录下HTML/css/js/image等等静态资源无法访问

<mvc:resources location="" mapping=""/>

<!-- SpringMVC框架自己处理静态资源，静态资源可以放在任意目录下 -->

<mvc:default-servlet-handler/>

<!-- 对请求URL进行判断，访问静态资源的交给Servlet容器处理，其他的交给映射器处理

静态资源必须在WebContent目录下

-->

2>导入SpringMVC对Ajax的支持包，借助Ajax客户端向服务器发送DELETE，PUT请求

3>在Controller中通过@RequestMapping注解，添加要处理的请求URL模板和Http请求的动作类型

4>利用@PathVariable注解将URL上的变量映射到处理方法的参数上

 

11、用过哪些数据库连接池,有什么区别

一 开源数据连接池
1 dbcp
dbcp可能是使用最多的开源连接池，原因大概是因为配置方便，而且很多开源和tomcat应用例子都是使用的这个连接池吧。
这个连接池可以设置最大和最小连接，连接等待时间等，基本功能都有。这个连接池的配置参见附件压缩包中的:dbcp.xml
使用评价：在具体项目应用中，发现此连接池的持续运行的稳定性还是可以，不过速度稍慢，在大并发量的压力下稳定性
有所下降，此外不提供连接池监控

2 c3p0
c3p0是另外一个开源的连接池，在业界也是比较有名的，这个连接池可以设置最大和最小连接，连接等待时间等，基本功能都有。
这个连接池的配置参见附件压缩包中的:c3p0.xml。
使用评价：在具体项目应用中，发现此连接池的持续运行的稳定性相当不错，在大并发量的压力下稳定性也有一定保证，
          此外不提供连接池监控。

12、MyBatis中${}和#{}有什么区别？

1、#先编译，然后在传值，传的值都是字符串;$直接拼接字符串

2、$会造成SQL注入，#不会

3、传入表名和列名可以用$

4、传入值的时候必须使用#，不要使用$

13、Spring中AutoWired和Resource之间区别是什么?

@AutoWired:spring框架自带注解

先按照类型进行匹配，如果存在多个匹配的类型会报错

@Resource：JavaEE中注解

推荐使用，解耦合；按照名称进行注入，查看spring容器中是否有bean对象的id值和引用名一样，

如果按照名称查找不到bean组件，就按照类型注入。

如果在容器中有多个匹配，可以强制按照名称注入。

@Autowired

@Qualifier("匹配的id值")或者@Resource(name="id值")；

 

14、Hibernate中延迟加载是什么,如何实现,如何取消？

 

延迟加载：lazy load 懒加载

在尽可能晚的情况下，真正需要使用到数据的时候，才会向数据库发送sql语句执行查询，加载

数据到内存中，避免了无谓的性能开销。

load()延迟加载：不发送SQL语句，而默认返回一个代理对象，只保存对象的ID值。

get()取消延迟加载：发送SQL语句，但是只会查询当前对象的完整信息，如果当前对象还有关

联的集合数据或者对象，默认都是延迟加载，不会发送SQL语句去查询其关联的对象或集合。

 

15、Hibernate的二级缓存和MyBatis二级缓存区别？

Hibernate和Mybatis的二级缓存除了采用系统默认的缓存机制外，都可以通过实现你自己的缓存或为其他第三方缓存方案，创建适配器来完全覆盖缓存行为。

不同点：Hibernate的二级缓存配置在SessionFactory生成的配置文件中进行详细配置；MyBatis的二级缓存配置都是在每个具体的表-对象映射中进行详细配置，这样针对不同的表可以自定义不同的缓存机制。并且Mybatis可以在命名空间中共享相同的缓存配置和实例，通过Cache-ref来实现。

两者比较：因为Hibernate对查询对象有着良好的管理机制，用户无需关心SQL。所以在使用二级缓存时如果出现脏数据，系统会报出错误并提示。

而MyBatis在这一方面，使用二级缓存时需要特别小心。如果不能完全确定数据更新操作的波及范围，避免Cache的盲目使用。否则，脏数据的出现会给系统的正常运行带来很大的隐患。

Hibernate与MyBatis都可以是通过SessionFactoryBuider由XML配置文件生成SessionFactory，然后由SessionFactory 生成Session，最后由Session来开启执行事务和SQL语句。

而MyBatis的优势是MyBatis可以进行更为细致的SQL优化，可以减少查询字段，并且容易掌握。

Hibernate的优势是DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。

 

16、Hibernate和MyBatis中分别是如何实现表之间的关联查询？

Hibernate：创建关联映射，在映射文件中的加入维持关系的外键名称

Mybatis：创建关联映射，在映射文件中添加多方集合属性名

17、Spring如何管理事物,事物的传播特性和隔离级别有哪些？

Spring并不直接管理事务，而是提供了多种事务管理器，他们将事务管理的职责委托给Hibernate或者JTA等持久化机制所提供的相关平台框架的事务来实现。

事物的传播特性：

1、原子性：指事物包含所有的操作要么完全成功，要么完全失败，事物的操作如果成功就必须要完全应用到数据库，如果失败就不能对数据库有任何的影响

2、一致性：指事物必须使数据库从一个一致性变换到另一个一致性，也就是说一个事物执行之前和执行之后都必须处于一个一致性状态。

3、隔离性：是当多个用户一起访问数据库时，操作同一个数据时，数据库为每一个用户开启事物，每个用户不被其他用户的事物影响干扰，多个并发事物之间要相互隔离。

4、持久性：指一个事物一旦被提交了，那么数据库的改变就是永久性的。即便是在系统遇到故障的情况下也不会丢失提交事物的操作。

隔离级别：

1、Serializable（串行化）：可避免脏读，不可重复读，幻读的发生。

2、Repeatable read(可重复读)：可避免脏读、不可重复读的发生。

3、Read committed(读已提交)：可避免脏读的发生。

4、Read uncommitted(读未提交)：最低级别，任何情况都无法保证。

最高级别的事Serializable级别，最低的是Read uncommitted级别。Mysql数据库中默认的隔离级别为Repeatable read（可重复读）

 

18、Struts如何实现文件上传下载.如何限制上传文件的大小和类型？

1、创建一个文件上传表单；表单提交方式为post，表单编码ectype=‘multipart/form-data'

限制文件上传大小

单个action：<param name="maximumSize">52428800</param>

整个项目设置：<constant name="struts.multipart.maxSize" value="2097152000"></constant>

 

19、Hibernate中对象的状态有哪些,他们之间是如何转换

1、临时态（瞬时态）：内存中有对象，数据库中没有与之对应的数据，新建的对象是临时状态，持久态的对象调用了delete()方法也会变成新建状态。

2、持久态：内存中有对象，数据库中有与之对应的数据，修改对象的属性，数据库中数据也会发生改变。持久状态的对象存在于内存的session缓存区域。

   新建状态调用了sava()或者saveOrUpdate()会变成持久状态。

   通过id从数据库get()或者load()出来的对象也是持久状态对象

   游离态对象调用save()或者saveOrUpdate()方法也会变成持久状态

3、游离态：内存中有对象，数据库有之对应的数据，但是对象处于离线状态，修改对象数据库中数据不会修改。

   Session关闭

清空session缓存

从session中剔除某个持久态对象

20、SpringMvc中的执行流程是什么,与Struts有什么区别？

1、页面向服务器发起请求，页面被提交到前端控制器

2、前端控制器接受到请求后调用处理器映射器HandlerMapping，映射器根据请求路径和映射规则找到相应的处理器Handler

3、前端控制器会根据映射器找到相应的处理器类型调用对应的设配器，适配器在调用处理器的业务方法

4、处理器中业务方法处理请求流程，处理完成之后会返回一个ModelAndView对象给处理器适配器

5、处理器适配器再将ModelAndView对象返回给前端控制器

6、前端控制器拿到ModelAndView对象之后取出其中的视图名称，在调用试图解析器找到相应的页面

7、在取出ModelAndView对象之后取出其中的视图名称，在调用视图解析器找到相应的页面

8、将JSP响应页面返回给客户端

21、SpringMvc适配器映射器和适配器处理作用分别是什么？他们之间有什么关系？

适配器映射器：根据请求路径以及映射规则找到对应的handler处理器

适配器：根据映射找到的处理器类型，调用不同的适配器，适配器去调用处理器中方法；

注解的映射器和适配器要配对使用

22、视图解析器的作用是什么？

前端控制器取出ModelAndView对象中的视图名称，在根据试图解析器中配置找到相应的试图页面

23、SpringMvc如何防止中文乱码问题？

1、自定义过滤器实现Filter接口，在相应的业务方法中对中文进行处理

2、使用spring框架自带的过滤器CharacterEncodingFilter

24、Struts2中如何给前端页面返回一个JSON字符串

用于向请求发起端返回一个JSON类型的字符串

<result-type name="json" class="org.apache.struts2.json.JSONResult"/>

1、引入一个插件： struts2-json-plugin-2.1.8.jar

2、package的extends必须继承json-default

3、result类型

<result name="success" type="json"></result>

4、在Action中定义的只要提供了set/get方法都会以json格式进行返回

5、如果只想返回Action中部分数据，将需要返回的数据存入到map中

<result name="success" type="json">

<param name="root">map</param>

</result>

 

25、Hibernate中get和load方法有什么区别？

1、load()方法启用延迟加载机制来进行查询，如果只调用load方法会返回一个代理对象，对象中只保存了id，不会向数据库发送sql语句，只有当访问了对象的非id属性时，才会向数据库发送sql语句；

2、get()方法只要调用了就会向数据库发送sql语句，查询完成后将对象信息返回来

注：根据id查不到对象：load方法会返回ObjectNotFoundException，get返回null；

26、如何编写HQL语句,他与SQL语句有什么异同点？

hql格式：from + 类名 + 类对象 + where + 对象的属性

sql是面向数据库表查询，格式：from + 表名 + where + 表中字段

HQL是一种面向对象的查询语言，面向Java实体类，与SQL语句没有关系，但是和SQL语句有相同的语法结构；

异同：

SQL面向数据库查询，HQL面向Java实体类查询

HQL中不支持SELECT*的写法。

SQL不支持除了分组函数（聚合函数，组函数）以外的其他函数。

HQL语句不支持表的连接查询。

占位符使用，下标从0开始；

27、在SSH整合中如何实现分页查询,如何使用二级缓存？

 

28、列举出Spring中常用注解

普通bean组件：@Component

三个衍生注解：@Repository  @Service  @Controller

管理bean对象生命周期注解：@PostConstruct 初始化方法  @PreDestory 销毁方法

管理bean对象作用域注解：@Scope

DI依赖注入：普通值注入：@Value

引用类型值的输入：@AutoWired（spring自带）@Resource（JavaEE自带）

@Qualifier

29、SpringMvc中处理器和JSP页面之间怎样传值

JSP页面传值给Controller处理器：

1、在方法中添加HTTPServletRequest对象

2、在方法中添加参数接受jsp传过来的值

   1．请求参数key和方法参数名一致，直接将值传给参数

   2.请求参数key和方法参数名不一致，利用@RequestParam（）注解

3、使用实体类对象接受请求参数

   1．创建实体类，实体类属性名和请求参数key名称一致

   2.在业务方法添加实体对象作为参数，通过实体接受请求参数

Controller处理器传值给JSP页面：

1、在方法中添加HttpServletRequest对象或者session对象

2、在业务方法中添加Model对象或者ModelMap对象，实质上是将值存在request中

3、在参数前添加@ModelAttribute

30、Ajax与SpringMvc之间怎样进行数据交互

Ajax:异步提交，页面无刷新

1、引入SpringMvc与Ajax交互核心开发包

jackson-annotations-2.9.2.jar

jackson-core-2.9.2.jar

jackson-databind-2.9.2.jar

2、SpringMvc怎么传值给Ajax

再返回值类前面或方法上加注解@ResponseBody，这样返回的数据就不会走视图解析器，

而是直接返回前端Ajax，前端Ajax会将拿到的数据解析为与JS相对应的类型

String-->string

boolean-->boolean

bean对象-->object(JSON对象)

List-->object(Array)

map-->object(JSON对象）

3、Ajax怎么提交值给SpringMvc

1、提交普通请求实体字符串类型到springmvc，springmvc可以直接接受

key1 = varlue&key2 = value2&....

2、提交JSON字符串到spring，需要在方法参数中加@RequestBody注解

'{"key1":value1,"key2":value2....}'

3、怎样将表单中数据序列化为JSON字符串

1.导入js/jquery.serializeJson-min.js

2.将表单中数据序列化成json对象

var requestData = $("form").serialize();

3.把json对象序列化成json字符串

var jsObj = JSON.stringify(jsonObj);

 

31、SpringMvc如何处理静态资源文件

32、SpringMvc中拦截器如何编写,它与Struts中拦截器有什么区别？

写一个类实现HandlerInterceptor接口

重写接口中拦截方法：

   preHandler 请求进入处理器之前调用

   afterCompletion   处理器执行完请求之后调用

   postHandle    响应返回给浏览器之前调用

33、SpringMvc对异常的处理方式有哪些？

1、try{}catch{}

2、全局异常处理器（处理所有controller抛出的异常）

   添加全局异常处理器，统一处理项目中异常

3、局部异常处理器（只能处理当前处理器中的异常）：

   在当前的处理器中定义一个处理器异常的方法，在方法中添加Exception参数接受异常

   在处理方法上添加@ExceptionHandler注解

34、SpringMvc如何返回重定向与转发类型视图

1、转发到一个JSP页面

   返回值String：return“视图名”；

35、Struts2与SpringMvc有什么异同点？

1、Struts2是类级别的拦截， 一个类对应一个request上下文，SpringMVC是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应,所以说从架构本身上SpringMVC就容易实现restful url,而struts2的架构实现起来要费劲，因为Struts2中Action的一个方法可以对应一个url，而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了。

2、由上边原因，SpringMVC的方法之间基本上独立的，独享request response数据，请求数据通过参数获取，处理结果通过ModelMap交回给框架，方法之间不共享变量，而Struts2搞的就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的，这不会影响程序运行，却给我们编码 读程序时带来麻烦，每次来了请求就创建一个Action，一个Action对象对应一个request上下文。
3、由于Struts2需要针对每个request进行封装，把request，session等servlet生命周期的变量封装成一个一个Map，供给每个Action使用，并保证线程安全，所以在原则上，是比较耗费内存的。

4、 拦截器实现机制上，Struts2有以自己的interceptor机制，SpringMVC用的是独立的AOP方式，这样导致Struts2的配置文件量还是比SpringMVC大。

5、SpringMVC的入口是servlet，而Struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。

6、SpringMVC集成了Ajax，使用非常方便，只需一个注解@ResponseBody就可以实现，然后直接返回响应文本即可，而Struts2拦截器集成了Ajax，在Action中处理时一般必须安装插件或者自己写代码集成进去，使用起来也相对不方便。

7、SpringMVC验证支持JSR303，处理起来相对更加灵活方便，而Struts2验证比较繁琐，感觉太烦乱。

8、Spring MVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高（当然Struts2也可以通过不同的目录结构和相关配置做到SpringMVC一样的效果，但是需要xml配置的地方不少）。

9、 设计思想上，Struts2更加符合OOP的编程思想， SpringMVC就比较谨慎，在servlet上扩展。

10、SpringMVC开发效率和性能高于Struts2。
11、SpringMVC可以认为已经100%零配置。

 

 

36、Hibernate与MyBatis有什么异同点

（1）Hibernate与MyBatis都是通过SessionFactoryBuider由XML配置文件生成SessionFactory，由SessionFactory 生成Session，由Session来开启执行事务和SQL语句。

（2）Hibernate和MyBatis都支持JDBC（Java DataBase Connectivity，java数据库连接）和JTA（Java Transaction API，Java事务API（Application Programming Interface，应用程序编程接口））事务处理。

注：jdbc和jta的主要作用是增强数据访问能力。

（3）基于ORM（Object Relational Mapping， 对象关系映射）思想解决了entity和数据库的映射问题

不同点：

（1）sql方面：mybaits通过mapper.xml维护映射结果，程序员手动编写sql相比hibernate自动生成hql（hibernate sql）更加灵活，sql调优更加容易（hibernate因为更好的封装性，开发效率提高的同时，sql语句调优要更费力，当然可以手动修改sql来优化，但是同时也会影响开发效率）；hibernate的hql数据库移植性更好，体现在强壮性。hibernate在级联删除的时候效率低；数据量大， 表多的时候，基于关系操作会变得复杂。

（2）缓存方面：mybatis和hibernate都可以使用第三方缓存，而hibernate相比maybatis有更好的二级缓存机制。

 

37、MyBatis接口映射规则

根据一定的映射规则，根据接口通过动态代理方式自动生成它的实现类

映射规则：

1、映射接口的全限定名必须和映射文件的namespace保持一致

2、映射接口中方法名必须和SQL定义语句的id保持一致

3、映射接口的方法的参数类型和SQL定义的parameterType保持一致

4、映射接口的返回值类型必须和SQL定义的resultType一致

update/delete/insert 返回值类型为void

 

建议规范

1、映射接口名后缀最好以Mapper结尾

2、映射文件放在与映射接口相同的包下面

 

38、Jquery如何发送Ajax请求

ajax() 方法通过 HTTP 请求加载远程数据。

该方法是 jQuery 底层 AJAX 实现。简单易用的高层实现见 $.get, $.post 等。$.ajax() 返回其创建的 XMLHttpRequest 对象。大多数情况下你无需直接操作该函数，除非你需要操作不常用的选项，以获得更多的灵活性。

最简单的情况下，$.ajax() 可以不带任何参数直接使用。

 

39、JS中常用数据类型有哪些

1.number          2.string    3.boolean         4.undefined      5.null        6.Object     7.symbol

40、JS对象的创建方式有哪些,如何将一个JS对象转换为JSON字符串?

创建对象的方式：

（1）、直接new对象

var obj = new Object（）；

//定义属性

obj.属性名= 属性值

//定义方法

obj.方法名= function（）{}

（2）、使用构造器构建对象

function Point（x，y）{

//属性

this.x= x;

this.y=y;

//方法

this.方法名=function（）{}

}

（3）、定义JSON格式的JS对象

var obj = {

属性名：属性值，

方法名：方法体

}；

将JSON字符串转换为JS对象

var obj = JSON.parse(jsonStr);

（4）、遍历对象中的属性和方法

for(key in Object) {

key:属性名和方法体

object[key]:属性值和方法体

}

使用  JSON.stringify(json);方法生成json的方法

41、Oracle分页,存储过程