面试官问题整理之基础篇

1.面向对象特征
封装：把描述一个对象的属性和行为封装在一个类中，属性用变量定义，行为用方法定义，方法可以访问同一个对象中的属性
继承：子类继承父类的特征和行为，子类可以有父类的方法，非私有变量，子类可以对父类进行扩展，也可以重写父类方法，
缺点：提高代码之间的耦合性
多态：程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定
比如：向上转型，只有运行才能确定其对象属性，方法重写和重载体现了多态性。
抽象：把现实生活中的对象抽象为类。分为过程抽象和数据抽象
数据抽象：鸟有翅膀,羽毛等(类的属性)
过程抽象：鸟会飞,会叫(类的方法)

2.hashmap的遍历

map.keyset
for(String key:map.keySet())
        {
         System.out.println("Key: "+key+" Value: "+map.get(key));
        }

map.entryset.iterator
Iterator map1it=map.entrySet().iterator();
        while(map1it.hasNext())
        {
         Map.Entry<String, String> entry=(Entry<String, String>) map1it.next();
         System.out.println("Key: "+entry.getKey()+" Value: "+entry.getValue());
        }

map.entryset
for(Map.Entry<String, String> entry: map.entrySet())
        {
         System.out.println("Key: "+ entry.getKey()+ " Value: "+entry.getValue());
        }

for(String v:map.values())
        {
         System.out.println("The value is "+v);
        }

3.常见的异常
1、空指针异常类：NullPointerException
2、数据类型转换异常：java.lang.ClassCastException
3、数组下标越界异常：java.lang.IndexOutOfBoundsException
4、字符串转换为数字异常：NumberFormatException
5、指定的类不存在： java.lang.ClassNotFoundException
6、方法的参数错误：java.lang.IllegalArgumentException

4.list和set的区别
list：有序可重复
set：无序不可重复
所以hashset继承了set接口，所以在将对象存储在hashset之前，保证对象重写了equals和hashcode方法，这样才能比较对象的值是否相等，确保存入的数据没有重复对象

5.arraylist，hashmap扩容
arraylist每次扩容是原来的1.5倍
hashmap每次扩容是原来的2倍

6.ArrayList和LinkedList的大致区别：
1.ArrayList是实现了基于动态数组的数据结构，LinkedList是基于链表结构。
2.对于随机访问的get和set方法，ArrayList要优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据
进行 查操作时用ArrayList，进行增删操作的时候最好用LinkedList

7.string stringbuffer stringbuilder区别

8.静态代码块是在运行时才能确定，在编译时不能确定

9.string：字符串常量。且是不可变的对象

10.hashmap的底层实现
HashMap 底层是数组+链表（以数组存储元素，如有 hash 相同的元素，在数组结构中，创建链表结构，再把 hash 相同的元素放到链表的下一个节点）， 基于 hashing (散列法（Hashing）或哈希法是一种将字符组成的字符串转换为固定长度（一般是更短长度）的数值或索引值的方法) 原理,通过 put() 和 get()方法来储存和获取对象。当我们将键值对传递给 put()方法的时候,调用键对象的 hashCode()方法来计算哈希值,然后找到 bucket(桶)位置来储存值对象。当我们要获取对象的时候，通过键对象的 equal()方法找到正确的键值对,然后返回值对象。HashMap使用链表来解决碰撞的问题,当发生碰撞了,对象就会储存在链表的下一个节点中。HashMap 在每个链表节点中储存键值对对象。
简单点就是：数组和链表，数组存储元素，如有hash相同的元素，在数组中创建链表，将hash相同的元素存入到链表的下一个节点中

11.转发和重定向区别
转发：客户端发出的请求，所以使用request调用
重定向：服务器作出的响应，所以使用response调用 ，页面跳转

12.redis里面存对象，怎么实现
redis是可以存字节的，所以，可以进行序列化

13.用哪两种方式来实现集合的排序？
你可以使用有序集合，如 TreeSet 或 TreeMap，你也可以使用有顺序的的集合，如 list，然后通过 Collections.sort() 来排序。

14.Java 中的 HashSet，内部是如何工作的？
HashSet 的内部采用 HashMap来实现。由于 Map 需要 key 和 value，所以所有 key 的都有一个默认 value。类似于 HashMap，HashSet 不允许重复的 key，只允许有一个null key，意思就是 HashSet 中只允许存储一个 null 对象

15.防止SQL注入
#在传入的时候将参数当成一个字符串，会自动加个双引号
$将传入的数据直接显示在sql中

16.hashmap和hashtable的区别
hashmap线程不安全的，hashtable线程安全
hashmap的key值可以为null，value值可以为null，hashtable不可以
hashtable是同步的，多个线程可以共享一个hashtable，hashmap非同步，没有正确同步的话，多个线程不可以共享一个hashmap

17.抽象类和接口的区别
抽象类可以有抽象方法，和非抽象方法，接口只有抽象方法
抽象类成员可以是变量/常量，接口只有常量
抽象类子类用extends来继承，只能单继承，接口使用implements来实现，可以多实现
抽象类的方法可以有public，protect，default，接口的默认修饰符只有public

18.final，finally，finalize区别
final：修饰符，类不可被继承，方法不可被覆盖，属性不可变
finally：try-catch-finally，表示总是执行
finalize：object类的一个方法，垃圾回收的时候会用到

19.123这三个线程，如何保证按照顺序进行
thread.join 原理是底层先用了wait进行线程阻塞，然后在使用notify和notifyall进行唤醒

20.讲讲类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字段，当 new 的时候， 他们的执行顺序(笔试题中常出现)
父类静态变量
父类静态代码块
子类静态变量
子类静态代码块
父类非静态变量
父类构造函数
子类非静态变量
子类构造函数

21.类中包含一个静态类

22.java的基本数据类型

23. 为什么要有包装类型
为了让基本类型也具有对象的特征，就出现了包装类型（如我们在使用集合类型Collection时就一定要使用包装类型而非基本类型）因为容器都是装object的，这是就需要这些基本类型的包装器类了。

声明方式不同：基本类型不使用new关键字，而包装类型需要使用new关键字来在堆中分配存储空间；
存储方式及位置不同：基本类型是直接将变量值存储在栈中，而包装类型是将对象放在堆中，然后通过引用来使用；
初始值不同：基本类型的初始值如int为0，boolean为false，而包装类型的初始值为null；
使用方式不同：基本类型直接赋值直接使用就好，而包装类型在集合如Collection、Map时会使用到。

24.集合

25.拦截器和过滤器的区别
拦截器是基于java的反射机制的，而过滤器是基于函数回调
拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用
拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问
在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次
拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑
执行顺序

过滤前-拦截前-Action处理-拦截后-过滤后

26.四种修饰符的区别
类 当前包 子类 其他包
public OK OK OK OK
protect OK OK OK NO
default OK OK NO NO
private OK NO NO NO
default 当前包，所以抽象方法不能用default修饰
private 当前类
protect 其他包不可以

27.假设try块中一个return语句的话,那么catch和finally中的代码还会执行吗?
会执行，但是return是指跳出这个语句块，finally又是必须要执行的，所以是先执行finally，再执行return

28.Spring的五种依赖注入方式
@Autowired

setter 方法注入

构造器注入

静态工厂的方法注入

实例工厂的方法注入

29.static和final区别

30.String s = "hello"和String s = new String(“hello”);区别

31.sql语句优化
1、问：select * from admin left join log on admin.admin_id = log.admin_id where og.admin_id>10 优化
优化为： select * from (select * from admin where admin_id>10) T1 lef join log
on T1.admin_id = log.admin_id
1.使用 JOIN 时候，应该用小的结果驱动大的结果（left join 左边表结果尽量小
如果有条件应该放到左边先处理，right join 同理反向），同事尽量把牵涉到
多表联合的查询拆分多个 query（多个连表查询效率低，容易到之后锁表和阻
塞）。

2、注意 LIKE 模糊查询的使用， 避免使用 %% ,可以使用 后面带% ，双%是不走索引 的。

3.limit 的基数比较大时使用 between
例：select * from admin order by admin_id limit 100000,10 优化 优化为：select * from admin where admin_id between 100000 admin 100010 order by admin_id

4.尽量避免在列上做运算，这样导致索引失效。
例：select * from admin where year(admin_time)>2014 优化 优化为： select * from admin where admin_time> '2014-01-01′

32.线程的流程
新建（NEW）新创建了一个线程对象。
可运行 （RUNNABLE）线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。
运行（RUNNING） 可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。
阻塞 （BLOCKED）线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态
(一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
(二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
(三). 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。
死亡 (DEAD) 线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

33.sleep() 和 wait() 有什么区别
sleep：thread类的静态方法
wait：object类的成员方法
sleep没有释放锁，wait释放了锁，使得其它线程可以使用同步控制块或者方法
wait，notify，notifyall只能在同步控制方法或者同步控制块中使用，sleep可以在任何地方使用。
一旦一个对象调用了wait方法，必须要采用notify()和notifyAll()方法唤醒该线程
一个线程对象调用了sleep方法之后，并不会释放他所持有的所有对象锁，所以也就不会影响其他进程对象的运行
延伸：object还有哪些方法？
13个方法

34.子类继承父类执行顺序
父类没有无参构造，存在有参构造方法

子类必须用supper关键子来调用父类带参数的构造方法，否则编译不能通过。

执行顺序

父类有所有的构造方法

子类有所有的构造方法

执行顺序

总结：子类的构造方法，不管这个构造方法带不带参数，默认的它都会先去寻找父类的不带参数的构造方法。如果父类没有不带参数的构造方法，那么子类必须用supper关键子来调用父类带参数的构造方法，否则编译不能通过。
静态代码块>非静态代码块>构造函数

总结：只有一个类时：静态代码块>主程序>非静态代码块,接下来顺序执行main里边的语句

当没有进行对象的创建时，并没有执行该类的非静态代码块

35.get请求传入的参数不能是一个对象，这是一个bug，必须传入具体的值，如username，不能传入user对象

36.如何存储一个对象里面的数据（三种方式）
克隆,序列化，变成json字符串

37.当数据库字段类型是date/timerstamp时,插入数据时，可以插入string类型

当数据库类型是timerstamp时，可以pojo中定义该字段为date类型实际上这两种类型几乎一样。


38.怎么样知道set里面是否有name=张三？
面试官规定使用hashset
HashSet hs = new HashSet();
hs.add(new Person(“张三”, 23));–可以放对象
数据少的话，set里面直接放个map

hashset里面放个对象，则如果System.out.println(“hashset:”+set)，打印的是一个地址，该地址表示的是person对象，我们只要在person类中重写tostring，则打印出来的就会有值
hashset:[Student{name=‘张三’, age=‘18’}, Student{name=‘李四’, age=‘20’}, Student{name=‘曹磊’, age=‘26’}]

39.jsp和servlet的区别
面试回答：servlet是一个完整的java类，而jsp不是，由html和java代码组合，
jsp的代码jvm识别不了，经web容器将jsp编译成jservlet才能被识别
servlet没有内置对象，jsp中的内置对象都是通过HttpServletRequest，HttpServletResponse，HttpServlet得到的

jsp经编译后就变成了Servlet.
(JSP的本质就是Servlet，JVM只能识别java的类，不能识别JSP的代码,Web容器将JSP的代码编译成JVM能够识别的java类)
jsp更擅长表现于页面显示,servlet更擅长于逻辑控制.
Servlet中没有内置对象，Jsp中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象以及HttpServlet对象得到.
Jsp是Servlet的一种简化，使用Jsp只需要完成程序员需输出要到客户端的内容，Jsp中的Java脚本如何镶嵌到一个类中，由Jsp容器完成。
而Servlet则是个完整的Java类，这个类的Service方法用于生成对客户端的响应。

40.spring的设计模式，应用场景
工厂模式：在各种BeanFactory以及ApplicationContext实现中也都用到了
模板模式：在各种BeanFactory以及ApplicationContext实现中也都用到了
代理模式：aop
策略模式：加载资源文件的方式，使用了不同的方法，比如：ClassPathResourece，FileSystemResource，ServletContextResource，UrlResource但他们都有共同的借口Resource；在Aop的实现中，采用了两种不同的方式，JDK动态代理和CGLIB代理
单例模式：创建bean的时候

41.sp动态和静态（include）
<%@ include file=”relativeURI”%> // 是在翻译阶段执行
<jsp:include page=”relativeURI” flush=”true” />// 在请求处理阶段执行.
对于静态包含，<%@include%>，中包含的文件（无论html文件还是jsp文件），只是简单的嵌入到主文件中，就是在jsp页面转化成Servlet时才嵌入到主文件中，因为运行的结果是只生成了一个Servlet。

而对于动态包含< jsp:incude>，如果被包含文件是动态的（jsp文件），那么就会生成两个Servlet，也就是被包含文件也要经过jsp引擎编译执行生成一个Servlet，两个Servlet通过request和reponse进行通信（包含的jsp是一个完整的文件有html、body等标签）。如果被包含的文件是静态的（html文件），那么这种情况和%@include就很相似，只生成了一个Servlet，但是他们之间没有进行简单的嵌入，而依然是通过request和reponse进行的通信

42…jsp9大内置对象，4大作用域？
内置对象（又叫隐含对象，有9个内置对象）:不需要预先声明就可以在脚本代码和表达式中随意使用。

作用域：page request session application
内置对象：request response page application out exception config pagecontext session