1.谈谈你对面向对象程序设计的理解？面向对象程序设计的重点和难点是什么？
对面向对象的理解
在我理解,面向对象是向现实世界模型的自然延伸，这是一种“万物皆对象”的编程思想。在现实生活中的任何物体都可以归为一类事物，而每一个个体都是一类事物的实例。面向对象的编程是以对象为中心，以消息为驱动，所以程序=对象+消息。
面向对象有三大特性，封装、继承和多态。
封装就是将一类事物的属性和行为抽象成一个类，使其属性私有化，行为公开化，提高了数据的隐秘性的同时，使代码模块化。这样做使得代码的复用性更高。
继承则是进一步将一类事物共有的属性和行为抽象成一个父类，而每一个子类是一个特殊的父类--有父类的行为和属性，也有自己特有的行为和属性。这样做扩展了已存在的代码块，进一步提高了代码的复用性。
如果说封装和继承是为了使代码重用，那么多态则是为了实现接口重用。多态的一大作用就是为了解耦--为了解除父子类继承的耦合度。如果说继承中父子类的关系式IS-A的关系，那么接口和实现类之之间的关系式HAS-A。简单来说，多态就是允许父类引用(或接口)指向子类(或实现类)对象。很多的设计模式都是基于面向对象的多态性设计的。
总结一下，如果说封装和继承是面向对象的基础，那么多态则是面向对象最精髓的理论。掌握多态必先了解接口，只有充分理解接口才能更好的应用多态。
原文：https://blog.csdn.net/weixin_40066829/article/details/78111476
2.什么是类，类实例，如何建立类的实例，在spring中又是如何创建类的？
类的具体表现或者实例就是对象，而对象的抽象或者总概括就是类。
创建对象的根本途径是构造器，通过new关键字来调用某个类的构造器即可创建这个类的实例
1 // 使用Person类定义一个Person类型的变量 2 Person p; 3 // 通过new关键字调用Person类的构造器,返回一个Person实例 4 // 将该Person实例赋给p变量 5 p = new Person();
上面代码也可简写成下面的形式:
1 // 定义p变量的同时并为p变量赋值 2 Person p = new Person();
spring创建对象的三种方式：
1、采用默认的构造函数创建
2、采用静态工厂方法
1、写一个静态工厂方法类
public class HelloWorldFactory { public static HelloWorld getInstance(){ return new HelloWorld(); } }
2、在spring的配置文件中进行声明
<bean id="helloWorld2" class="com.itheima05.spring.bean.HelloWorldFactory" factory-method="getInstance"></bean>
告诉spring容器利用HelloWorldFactory类中的getInsatance静态方法产生对象
但是具体的对象的创建的过程是由程序员来完成的
3、实例工厂方法
1、写一个实例工厂类
public class HelloWorldFactory {
public HelloWorld getInstance(){
return new HelloWorld();
}
}
2、在spring的配置文件中
1、<bean id="helloWorld3" class="com.itheima05.spring.bean.HelloWorldFactory2"></bean>
spring容器为HelloWorldFactory2创建对象
2、<bean id="helloWorldFactory" factory-bean="helloWorld3" factory-method="getInstance"></bean>
告诉spring容器，利用helloWorld3对象调用getInstance方法
创建对象的时机
1、在默认的情况下，在spring容器启动的时候创建对象
在spring配置文件中，只要根据以上的三种方式的其中一种配置了，spring容器就会创建对象
好处：spring容器和web容器整合的时候，当web容器启动的时候就可以初始化spring容器了，如果这个时候
spring容器内部有错误，则直接会报错
如果该bean中存放着大量的数据，而且数据的初始化发生在创建对象的时候，这个时候，数据会过早的驻留在内存中
2、如果在spring的配置文件中一个bean的配置中有lazy-init="true"，那么该bean在调用getBean方法时创建对象
不好处：不能过早的发现错误
好处：按照需求加载数据(什么时候要什么时候加载)
3.什么是抽象类?什么是接口?
抽象类：抽象类就是不能使用new方法进行实例化的类，即没有具体实例对象的类，抽象类有点类似于“模板”的作用,目的是根据其格式来创建和修改新的类，对象不能由抽象类直接创建，只可以通过抽象类派生出新的子类，再由其子类来创建对象，当一个类被声明为抽象类时，要在这个类前面加上修饰符abstract,在抽象类中的成员方法可以包括一般方法和抽象方法
抽象方法：抽象方法就是以abstract修饰的方法，这种方法只声明返回的数据类型，方法名称和所需要的参数，没有方法体，也就是说抽象方法只需要声明而不需要事先，当一个方法为抽象方法时，意味着这个方法必须被子类的方法所重写，否则其子类的该方法仍然是abstract的，而这个子类也必须是抽象的，即声明为avstract
两者联系：抽象类中不一定包含抽象方法，但是包含抽象方法的类一定要被声明为抽象类，抽象类本身不具备实际的功能，只能用于派生其子类，抽象类中可以包含构造方法，但是构造方法不能被声明为抽象，抽象类不能用final来修饰，即一个类不能既是最终类又是抽象类，abstract不能与private，static,final,native并列修饰同一个方法
接口:
Java接口是一些方法特征的集合，没有方法的实现。Java接口中定义的方法在不同的地方被实现(implements)，可以具有完全不同的行为（功能）。
注意：(1)、java接口不能被实例化。
(2)、Java接口中声明的成员自动设置为public，因此java接口中不能声明私有的成员。
(3)、Java接口中不能出现方法体实现。
(4)、实现(implements)某个java接口，就必须实现其中定义的所有方法。
接口(interface)的特征:
1.所有的成员变量都是public、static、final类型。
2.所有的方法都是public、abstract类型。
3.所有的嵌套类型（类或接口）都是public、static类型。
抽象类（abstract class）和接口（interface）有什么异同？
答：抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。一个类如果继承了某个抽象类
或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。接口比
抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器 而且其中的方法全部都是抽象方法。抽象类中的成员可以是 private、默认、protected、public 的，而接口中 的成员全都是 public 的。抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象 方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。
4.什么是内部类？内部类有什么好处？
大部分时候，类被定义成一个独立的程序单元.在某些情况下，也会把一个类放在另一个类的内部定义,这个定义在其他类内部的类就被称为内部类，包含内部类的类也被称为外部类。
内部类主要有如下作用：
（1）内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。
（2）内部类成员可以直接访问外部类的私有数据，因为内部类被当成其外部类成员，同一个类的成员之间可以换互相访问。但外部类不能访问内部类的实现细节。
（3）匿名内部类适合用于创建那些仅需要一次使用的类。
补充：
从语法角度来看，定义内部类与定义外部类的语法大致相同，内部类除需要定义在其他类里面之外，还存在如下两点区别：
（1）内部类比外部类可以多使用三个修饰符：private、protected、static——外部类不可以使用这三个修饰符。
（2）非静态内部类不能拥有静态成员。
5.如何进行整数、浮点数和字符串间的转换？
- 调用基本数据类型对应的包装类中的方法 parseXXX(String)或 valueOf(String)即可返回相应基本类型；
- 一种方法是将基本数据类型与空字符串（""）连接（+）即可获得其所对应的字符串；另一种方法是调用 String 类中的 valueOf()方法返回相应字符串
6.说说continue如何控制循环过程的执行。
（1）break;
while循环break是用于永久终止循环。即不执行本次循环中break后面的语句，直接跳出循环。
（2）continue;
while循环continue是用于终止本次循环。即本次循环中continue后面的代码不执行，进行下一次循环的入口判断。
7.说说你对泛型的理解。
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
8.说说Java中异常的分类，以及Java程序中是如何处理异常的。
Throwable类是Java异常类型的顶层父类，一个对象只有是 Throwable 类的（直接或者间接）实例，他才是一个异常对象，才能被异常处理机制识别。JDK中内建了一些常用的异常类，我们也可以自定义异常。
Throwable又派生出Error类和Exception类。
错误：Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。
异常：Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。
Java 通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在 Java 中，每个异常都是一个对象，它是 Throwable 类或其子类的实例。当一个方法出现异常后便抛出一个异常 对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并可以对其进行处理。Java 的 异常处理是通过 5 个关键词来实现的：try、catch、throw、throws 和 finally。一般情况下是用 try 来执行一 段程序，如果系统会抛出（throw）一个异常对象，可以通过它的类型来捕获（catch）它，或通过总是执行 代码块（finally）来处理；try 用来指定一块预防所有异常的程序；catch 子句紧跟在 try 块后面，用来指定 你想要捕获的异常的类型；throw 语句用来明确地抛出一个异常；throws 用来声明一个方法可能抛出的各 种异常（当然声明异常时允许无病呻吟）；finally 为确保一段代码不管发生什么异常状况都要被执行；try语 句可以嵌套，每当遇到一个 try 语句，异常的结构就会被放入异常栈中，直到所有的 try 语句都完成。如果 下一级的 try 语句没有对某种异常进行处理，异常栈就会执行出栈操作，直到遇到有处理这种异常的 try 语 句或者最终将异常抛给 JVM。
9.说说进程和线程的区别，Java中如何创建线程？
区别：
（1）进程是资源的分配和调度的一个独立单元，而线程是CPU调度的基本单元
（2）同一个进程中可以包括多个线程，并且线程共享整个进程的资源（寄存器、堆栈、上下文），一个进行至少包括一个线程。
（3）进程结束后它拥有的所有线程都将销毁，而线程的结束不会影响同个进程中的其他线程的结束
（4）线程是轻两级的进程，它的创建和销毁所需要的时间比进程小很多，所有操作系统中的执行功能都是创建线程去完成的
（5）线程中执行时一般都要进行同步和互斥，因为他们共享同一进程的所有资源
（6）线程有自己的私有属性TCB，线程id，寄存器、硬件上下文，而进程也有自己的私有属性进程控制块PCB，这些私有属性是不被共享的，用来标示一个进程或一个线程的标志
Java 5 以前实现多线程有两种实现方法：一种是继承 Thread 类；另一种是实现 Runnable 接口。两种方 式都要通过重写 run()方法来定义线程的行为，推荐使用后者，因为 Java 中的继承是单继承，一个类有一个 父类，如果继承了 Thread 类就无法再继承其他类了，显然使用 Runnable 接口更为灵活。
补充：Java 5 以后创建线程还有第三种方式：实现 Callable 接口，该接口中的 call 方法（线程执行体）可以在线程执行结束时产生一个返回值
10.什么是注解？试举例你使用过的注解。
a) xml, eXtensible Markup Language, 可扩展标记语言. 是一种标记语言.
b) xml是一种非常灵活的语言, 没有固定的标签, 所有的标签都可以自定义.
c) 通常, xml被用于信息的记录和传递. 因此, xml经常被用于充当配置文件.
Web Service:
从表面上看，Web Service 就是一个应用程序，它向外界暴露出一个能够通过 Web 进行调用的 API。这 就是说，你能够用编程的方法透明的调用这个应用程序，不需要了解它的任何细节，跟你使用的编程语言 也没有关系。例如可以创建一个提供天气预报的 Web Service，那么无论你用哪种编程语言开发的应用都可 以通过调用它的 API 并传入城市信息来获得该城市的天气预报。之所以称之为 Web Service，是因为它基于 HTTP 协议传输数据，这使得运行在不同机器上的不同应用无须借助附加的、专门的第三方软件或硬件，就 可相互交换数据或集成。 补充：这里必须要提及的一个概念是 SOA（Service-Oriented Architecture，面向服务的架构），SOA 是一种思 想，它将应用程序的不同功能单元通过中立的契约联系起来，独立于硬件平台、操作系统和编程语言，使 得各种形式的功能单元能够更好的集成。显然，Web Service 是 SOA 的一种较好的解决方案，它更多的是一 种标准，而不是一种具体的技术。
Json:
JSON是JavaScript Object Notation的简称，中文含义为“JavaScript 对象表示法”，它是一种数据交换的文本格式，而不是一种编程语言。
JSON 是一种轻量级的数据交换格式，它基于 ECMAScript (w3c制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。
---------------------------------------------------------------------------------------------------------------------
json简介
百度百科：
JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。它基于 ECMAScript 规范的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。
什么是 JSON ？
JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation）
JSON 是轻量级的文本数据交换格式
JSON 独立于语言 *
JSON 具有自我描述性，更易理解
* JSON 使用 JavaScript 语法来描述数据对象，但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON 库支持许多不同的编程语言。
类似 XML
JSON 是纯文本
JSON 具有“自我描述性”（人类可读）
JSON 具有层级结构（值中存在值）
JSON 可通过 JavaScript 进行解析
JSON 数据可使用 AJAX 进行传输
相比 XML 的不同之处
没有结束标签
更短
读写的速度更快
能够使用内建的 JavaScript eval() 方法进行解析
使用数组
不使用保留字
-------------------------------------------------------------------------------------------------------------------
14.三大框架的作用
三大框架是用来开发web应用程序中使用的.
Struts:基于MVC的充当了其中的视图层和控制器
Hibernate:做持久化的,对JDBC轻量级的封装,使得我们能过面向对象的操作数据库
Spring: 采用了控制反转的技术,管理Bean,降低了各层之间的耦合.
15.什么是MVC
Model View Controller，是模型-视图-控制器的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个组件里，在改进和个性化定制界面的及用户交互的时候，不需要重新编写业务逻辑。mvc用于映射传统的输入、处理、输出功能在一个逻辑的图形用户界面的结构中。
mvc就是类似三层的一种架构，主要采用封装（分层）的思想，来降低耦合度，从而使我们的系统更灵活，扩展性更好。
（1）model是应用程序中用于处理数据逻辑的部分。通常模型对象负责在数据库中存取数据。
（2）view是应用程序中处理数据显示的部分。通常视图是依据数据模型创建的。
（3）controller是应用程序中处理数据交互的部分。通常控制器负责从视图读取数据，控制用户输入，并向模型发送。
模型（Model） “数据模型”（Model）用于封装与应用程序的业务逻辑相关的数据以及对数据的处理方法。“模型”有对数据直接访问的权力，例如对数据库的访问。“模型”不依赖“视图”和“控制器”，也就是说，模型不关心它会被如何显示或是如何被操作。但是模型中数据的变化一般会通过一种刷新机制被公布。为了实现这种机制，那些用于监视此模型的视图必须事先在此模型上注册，从而，视图可以了解在数据模型上发生的改变。
视图（View） 视图层能够实现数据有目的的显示（理论上，这不是必需的）。在视图中一般没有程序上的逻辑。为了实现视图上的刷新功能，视图需要访问它监视的数据模型（Model），因此应该事先在被它监视的数据那里注册。
控制器（Controller） 控制器起到不同层面间的组织作用，用于控制应用程序的流程。它处理事件并作出响应。“事件”包括用户的行为和数据模型上的改变。
补充：
1、mvc的优点
（1）多个视图共享一个模型，大大提高代码的可重用性。
（2）三个模块相互独立，改变其中一个不会影响其他两，所以依据这种设计模式能构建良好的松耦合性的组件。
（3）控制器提高了应用程序的灵活性和可控制性。控制器可以用来连接不同的模型和视图去完成用户的需求，这样控制器可以为构造应用程序提高强有力的手段。
2、mvc的缺点
（1）增加了系统结构和实现的复杂性。
对于简单页面，严格遵循mvc，使模型、视图与控制器分离，会增加结构的复杂性，并可能产生过多的更新操作，降低运行效率。
（2）视图与控制器过于紧密的连接。
视图与控制器是相互分离，但确实联系紧密的部件，视图没有控制器的存在，其应用是很有限的，反之亦然，这样就妨碍了他们的独立重用。
（3）视图对模型数据的低效率访问。
依据模型操作接口的不同，视图可能需要多次调用才能获得足够的显示数据。对未变化数据的不必要的频繁访问，也将损害操作性能。
（4）目前，一些高级的界面工具或构造器不支持mvc。
改造这些工具以适应MVC需要和建立分离的部件的代价是很高的，从而造成使用MVC的困难。
综上，对于开发存在大量用户界面，并且业务逻辑复杂的大型应用程序，MVC将会使你的软件在健壮性、代码重用和结构方面上一个新的台阶。尽管在最初构建MVC框架时会花费一定的工作量，但从长远角度看，它会大大提高后期软件开发的效率。所以我们在具体适用时，要综合考虑其适用范围，
16.jsp与servlet的区别与联系
jsp和servlet的区别和联系：
1.jsp经编译后就变成了Servlet.
(JSP的本质就是Servlet，JVM只能识别java的类，不能识别JSP的代码,Web容器将JSP的代码编译成JVM能够识别的java类)
2.jsp更擅长表现于页面显示,servlet更擅长于逻辑控制.
3.Servlet中没有内置对象，Jsp中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象以及HttpServlet对象得到.
Jsp是Servlet的一种简化，使用Jsp只需要完成程序员需要输出到客户端的内容，Jsp中的Java脚本如何镶嵌到一个类中，由Jsp容器完成。
而Servlet则是个完整的Java类，这个类的Service方法用于生成对客户端的响应。
联系：
JSP是Servlet技术的扩展，本质上就是Servlet的简易方式。JSP编译后是“类servlet”。
Servlet和JSP最主要的不同点在于：
Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。
而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。
JSP侧重于视图，Servlet主要用于控制逻辑
Servlet更多的是类似于一个Controller，用来做控制。
理解以下三点即可：
1、不同之处在哪？
- Servlet在Java代码中通过HttpServletResponse对象动态输出HTML内容
- JSP在静态HTML内容中嵌入Java代码，Java代码被动态执行后生成HTML内容
2、各自的特点
- Servlet能够很好地组织业务逻辑代码，但是在Java源文件中通过字符串拼接的方式生成动态HTML内容会导致代码维护困难、可读性差
- JSP虽然规避了Servlet在生成HTML内容方面的劣势，但是在HTML中混入大量、复杂的业务逻辑同样也是不可取的
既然JSP和Servlet都有自身的适用环境，那么能否扬长避短，让它们发挥各自的优势呢？答案是肯定的——MVC(Model-View-Controller)模式非常适合解决这一问题。
MVC模式（Model-View-Controller）是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）：
- Controller——负责转发请求，对请求进行处理
- View——负责界面显示
- Model——业务功能编写（例如算法实现）、数据库设计以及数据存取操作实现
在JSP/Servlet开发的软件系统中，这三个部分的描述如下所示：
- Web浏览器发送HTTP请求到服务端，被Controller(Servlet)获取并进行处理（例如参数解析、请求转发）
- Controller(Servlet)调用核心业务逻辑——Model部分，获得结果
- Controller(Servlet)将逻辑处理结果交给View（JSP），动态输出HTML内容
- 动态生成的HTML内容返回到浏览器显示
MVC模式在Web开发中的好处是非常明显，它规避了JSP与Servlet各自的短板，Servlet只负责业务逻辑而不会通过out.append()动态生成HTML代码；JSP中也不会充斥着大量的业务代码。这大大提高了代码的可读性和可维护性。
// 加载驱动。 Class.forName("oracle.jdbc.driver.OracleDriver"); // 创建连接。 Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger"); // 创建语句。 PreparedStatement ps = con.prepareStatement("select * from emp where sal between ? and ?"); ps.setInt(1, 1000); ps.setInt(2, 3000); // 执行语句。 ResultSet rs = ps.executeQuery(); // 处理结果。 while(rs.next()) { System.out.println(rs.getInt("empno") + " - " + rs.getString("ename")); } // 关闭资源。 finally { if(con != null) { try { con.close(); } catch (SQLException e) { e.printStackTrace(); } } }
Statement 和 PreparedStatement 有什么区别？哪个性能更好？
答：与 Statement 相比，①PreparedStatement 接口代表预编译的语句，它主要的优势在于可以减少 SQL的 编译错误并增加 SQL 的安全性（减少 SQL 注射攻击的可能性）；②PreparedStatement 中的 SQL 语句是可以 带参数的，避免了用字符串连接拼接 SQL 语句的麻烦和不安全；③当批量处理 SQL 或频繁执行相同的查询 时，PreparedStatement 有明显的性能上的优势，由于数据库可以将编译优化后的 SQL 语句缓存起来，下次 执行相同结构的语句时就会很快（不用再次编译和生成执行计划）。
18.用Java 写一个冒泡排序。
冒泡排序的思想
该排序算法意在从后往前像气泡一样，依次冒出数组中值小的元素；或者从前往后依次冒出数组中值大的元素。
以升序为例，假设数组的长度为size。从数组的最后一个元素（即第size-1个元素）开始，从后往前两两进行比较，即最开始比较第size-1个元素和第size-2个元素的值的大小，若发现前者比后者小，则进行交换，否则不交换，之后不管是否已进行交换操作，继续往前遍历，遍历到第0个元素为止，这时候确定第0个元素为数组中最小的值；然后，再重新开始比较第size-1个元素和第size-2个元素的值的大小，对其进行前面所述的操作，直到遍历到第1个元素为止，这时候确定第1个元素为数组中第二小的值；以此类推，直到对整个数组操作完为止。
public static void swap( int [] arr, int a, int b) { int temp = arr[a]; arr[a] = arr[b]; arr[b] = temp; } /* 冒泡排序。 */ public static void bubbleSort( int [] arr) { for ( int x=0; x<arr.length-1; x++) { for ( int y=0; y<arr.length-1-x; y++) { if (arr[y]>arr[y+1]){ swap(arr,y,y+1); } } } }
19、用Java 写一个折半查找。
答：折半查找，也称二分查找、二分搜索，是一种在有序数组中查找某一特定元素的搜索算法。搜素过程 从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；如果某一特定元素大于或
者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。
如果在某一步骤数组已经为空，则表示找不到指定的元素。这种搜索算法每一次比较都使搜索范围缩小一 半，其时间复杂度是 O(logN)。 import java.util.Comparator;
1 public static int halfSearch( int [] arr, int key) { 3 int max,min,mid; 4 min = 0; 5 max = arr.length-1; 6 mid = (max+min)/2; 7 while (arr[mid]!=key) { 9 if (key>arr[mid]) 10 min = mid + 1; 11 else if (key<arr[mid]) 12 max = mid - 1; 13 if (max<min) 14 return -1; 15 mid = (max+min)/2; 16 } 17 return mid; 18 }
20.Java实现同步的几种方式
https://www.cnblogs.com/jiansen/p/7351872.html
编写多线程程序有几种实现方式？
答：Java 5 以前实现多线程有两种实现方法：一种是继承 Thread 类；另一种是实现 Runnable 接口。两种方 式都要通过重写 run()方法来定义线程的行为，推荐使用后者，因为 Java 中的继承是单继承，一个类有一个 父类，如果继承了 Thread 类就无法再继承其他类了，显然使用 Runnable 接口更为灵活。
补充：Java 5 以后创建线程还有第三种方式：实现 Callable 接口，该接口中的 call 方法可以在线程执行结束时产生一个返回值.
synchronized 关键字的用法？
答：synchronized 关键字可以将对象或者方法标记为同步，以实现对对象和方法的互斥访问，可以用 synchronized(对象) { … }定义同步代码块，或者在声明方法时将 synchronized 作为方法的修饰符。
什么是线程同步 如何实现线程同步
当使用多个线程来访问同一个数据时，非常容易出现线程安全问题(比如多个线程都在操作同一数据导致数据不一致),所以我们用同步机制来解决这些问题。
实现同步机制有两个方法：
1.同步代码块：
synchronized(同一个数据){} 同一个数据：就是N条线程同时访问一个数据。
2.同步方法：
public synchronized 数据返回类型 方法名(){}
就是使用 synchronized 来修饰某个方法，则该方法称为同步方法。对于同步方法而言，无需显示指定同步监视器，同步方法的同步监视器是 this 也就是该对象的本身（这里指的对象本身有点含糊，其实就是调用该同步方法的对象）通过使用同步方法，可非常方便的将某类变成线程安全的类，具有如下特征：
1，该类的对象可以被多个线程安全的访问。
2，每个线程调用该对象的任意方法之后，都将得到正确的结果。
3，每个线程调用该对象的任意方法之后，该对象状态依然保持合理状态。
注：synchronized关键字可以修饰方法，也可以修饰代码块，但不能修饰构造器，属性等。
实现同步机制注意以下几点： 安全性高，性能低，在多线程用。性能高，安全性低，在单线程用。
1，不要对线程安全类的所有方法都进行同步，只对那些会改变共享资源方法的进行同步。
2，如果可变类有两种运行环境，当线程环境和多线程环境则应该为该可变类提供两种版本：线程安全版本和线程不安全版本(没有同步方法和同步块)。在单线程中环境中，使用线程不安全版本以保证性能，在多线程中使用线程安全版本.
21.Druid 连接池简介
Druid首先是一个数据库连接池。Druid是目前最好的数据库连接池，在功能、性能、扩展性方面，都超过其他数据库连接池，包括DBCP、C3P0、BoneCP、Proxool、JBoss DataSource。Druid已经在阿里巴巴部署了超过600个应用，经过一年多生产环境大规模部署的严苛考验。
同时Druid不仅仅是一个数据库连接池，它包括四个部分：
Druid是一个JDBC组件，它包括三个部分：
基于Filter－Chain模式的插件体系。
DruidDataSource 高效可管理的数据库连接池。
SQLParser
Druid的功能
1、替换DBCP和C3P0。Druid提供了一个高效、功能强大、可扩展性好的数据库连接池。
2、可以监控数据库访问性能，Druid内置提供了一个功能强大的StatFilter插件，能够详细统计SQL的执行性能，这对于线上分析数据库访问性能有帮助。
3、数据库密码加密。直接把数据库密码写在配置文件中，这是不好的行为，容易导致安全问题。DruidDruiver和DruidDataSource都支持PasswordCallback。
4、SQL执行日志，Druid提供了不同的LogFilter，能够支持Common-Logging、Log4j和JdkLog，你可以按需要选择相应的LogFilter，监控你应用的数据库访问情况。
5、扩展JDBC，如果你要对JDBC层有编程的需求，可以通过Druid提供的Filter机制，很方便编写JDBC层的扩展插件。
22.Dubbo（原文：https://blog.csdn.net/houshaolin/article/details/76408399）
1. 服务提供者在启动时，向注册中心注册自己提供的服务。
2. 服务消费者在启动时，向注册中心订阅自己所需的服务。
3. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
4. 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
5. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。
23.转发和重定向的区别？
请求转发 ：
a) 只发送一次请求
b) 地址栏不发生改变
c) 数据可以一直传递
d) 只能跳转内部资源, 不能访问外部资源
// 请求转发
req.getRequestDispatcher("dis2").forward(req, resp);
重定向：
a) 会发送多次请求
b) 地址栏会发生改变
c) 数据不能继续传递
d) 内部资源和外部资源都可以访问
// 重定向 resp.sendRedirect("red2?mouse="+req.getParameter("mouse"));
forward 是容器中控制权的转向，是服务器请求资源，服务器直接访问目标地址的 URL，把那个 URL 的 响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的， 所以它的地址栏中还是原来的地址。redirect 就是服务器端根据逻辑，发送一个状态码，告诉浏览器重新去 请求那个地址，因此从浏览器的地址栏中可以看到跳转后的链接地址，很明显 redirect 无法访问到服务器 保护起来资源，但是可以从一个网站 redirect 到其他网站。forward 更加高效，所以在满足需要时尽量使用 forward（通过调用 RequestDispatcher 对象的 forward()方法，该对象可以通过 ServletRequest 对象的 getRequestDispatcher()方法获得），并且这样也有助于隐藏实际的链接；在有些情况下，比如需要访问一个 其它服务器上的资源，则必须使用重定向（通过 HttpServletResponse 对象调用其 sendRedirect()方法实现）。
24.JSP 有哪些内置对象？作用分别是什么？
JSP 有 9 个内置对象：
- request：封装客户端的请求，其中包含来自 GET 或 POST请求的参数；
- response：封装服务器对客户端的响应；
- pageContext：通过该对象可以获取其他对象；
- session：封装用户会话的对象；
- application：封装服务器运行环境的对象；
- out：输出服务器响应的输出流对象；
- config：Web 应用的配置对象；
- page：JSP 页面本身（相当于 Java 程序中的 this）；
- exception：封装页面抛出异常的对象。