JAVA开发面试笔记

========================

js中两个变量能直接比较大小吗？

js中var定义的变量是字符串，如果两个变量直接比较大小是会有问题的，应该先转换成int比较，

比如21 和3 比较 如果没有经过转换则会认为3大，

 if(parseInt(num2)>parseInt(num1))  {}//正确

if(num2>num1){}//错误

========================

请简单介绍设计模式

单例模式可以确保一个类只有一个实例，利用getInstance 方法；

工厂模式提供创建对象接口，简单工厂模式由工厂类角色，抽象工厂角色和具体工厂角色。工厂类角色是核心类

========================

介绍synchronized关键字原理

加上synchronized后的方法，当有一个线程访问该方法时，其他的线程则必须等待

========================

你的系统如何分配和管理权限

可以利用数据库查询当前用户的权限，决定当前菜单是否展示

三个表 操作员表 t_cmm_oper 操作员角色表t_cmm_operrole(权限是以角色为单位的，比如风控角色权限，财务角色权限)，具体的权限表 t_cmm_funcrole

t_cmm_oper 和 t_cmm_operrole 通过操作员号oper_no关联；

t_cmm_operrole 和 t_cmm_funcrole 通过角色号role_id关联。

如果该用户存在对该菜单的权限则展示，如果没有则不展示

https://zhidao.baidu.com/question/183489178.html

========================

面向对象设计方法

该名词 面向对象设计方法 可拆分成 面向对象设计+方法

面向对象设计的方法就是在需求、概要设计基础上，划分对象-》抽象类-》将类组成为层次化结构

(继承)-》用类与实例进行设计和实现几个阶段。

http://blog.sina.com.cn/s/blog_5f2f1dd10100dgof.html

========================

介绍异常处理机制

关键字 try catch finally throw throws

异常总共有两种 ： ERROR 和 Exception 这两个类继承自Throwable

ERROR 一般是虚拟机相关问题

Exception 包含运行时异常RuntimeException 和非运行时异常non-RuntimeException,比如说数组下标越界，类找不到 ClassNotFoundException，文件找不到 FileNotFoundException，文件输入输出异常IOException

========================

concurrent包 了解吗 -----该题的回答可能有问题，正确的回答可能是 java.util.concurrent包包含能帮助人们管理相互合作的线程集的类。

java.util.concurrent包分成了三个部分，分别是java.util.concurrent、java.util.concurrent.atomic和java.util.concurrent.lock。内容涵盖了并发集合类、线程池机制、同步互斥机制、线程安全的变量更新工具类、锁等等常用工具。

Executors

Lock

多线程编程中常常要锁定某个对象，之前会用synchronized来实现，现在又多了另一种选择，那就是java.util.concurrent.locks。通过Lock能够实现更灵活的锁定机制，它还提供了很多synchronized所没有的功能，例如尝试获得锁(tryLock())。

 使用Lock时需要自己获得锁并在使用后手动释放，这一点与synchronized有所不同，所以通常Lock的使用方式是这样的：

Lock l = ...;

l.lock();

try {

// 执行操作

} finally {

l.unlock();

}

并发集合类

java.util.concurrent包中提供了几个并发结合类，例如ConcurrentHashMap、ConcurrentLinkedQueue和CopyOnWriteArrayList等等，根据不同的使用场景，开发者可以用它们替换java.util包中的相应集合类。

http://blog.csdn.net/legendmohenote/article/details/5754117

========================

你设计的时候如何实现接口分离

首先定义一个类 ServiceImp实现所有的方法，然后每个类都有专有的接口类ServiceX

采用的是接口分离原则，这个对每个客户类都有一个专用的接口，这个接口中只声明了与这个客户类相关的方法，而ServiceImp类实现了所有的接口。如果ClientA要改变它所使用的接口中的方法，只需改动ServiceA接口和ServiceImp类即可，ClientB和ClientC类不受影响。如果直接实现ServiceImp，修改clientA 则clientB ，clientC 都要跟着修改

第一幅图是接口分离型，第二幅图是接口未分离型

http://baike.baidu.com/link?url=yZ0d-4fEaBOvHAwGjZpGjG5V5gXwt2GTwOWPbJbn-1z_4PdkC1G_z9a5_ke3wbG9X7dqvusqUxOKO9Pcq-nA1HHEyplUFvMpa7hS5DmXPaAIJITliYYaYd1CjQPNwlnPaav2TdD1EWTsdh3SpeGq9K

========================

UML 中类之间有哪些关系？

关联 类似于客户和订单的关系

依赖 依赖是指的类之间的调用关系，类似于自行车和打气筒的关系

聚合 聚合是整体和部分之间的关系，类似于计算机和主板的关系

组合 组合也是整体和部分之间的关系，跟聚合类似，但是组合的各部分不可分割，分割了就没有意义，比如人的头和手，头和手从人上分割下来就没有意义了 。

泛化 泛化就是继承。例如人和学生两个类，学生类是人类的泛化

实现 即一个类实现了一个接口

http://blog.sina.com.cn/s/blog_59ca2c2a01012ido.html

========================

gc太频繁 如何处理

JVM在进行GC时，内存中存在新生代 Young Generation，老年代Old Generation，永久代 PermGen

新生代包括三个区Eden, From(surviver1) ,To(surviver2)

一个对象首先在Eden中生成，然后传入From,然后To， GC在在新生代中非常频繁。

老年代 一般存放几次GC仍然存活的对象，还有比较大的对象，生命周期比较长的对象。

对象生命周期类比人类的年龄，新创建的对象放入新生代的Eden,老的放入老年代 Old Generation

永久代: 永久代存放类的定义，类的字节码

gc 太频繁可通过如下处理：扩充内存的heap

http://blog.csdn.net/sinat_25306771/article/details/52258417

========================

hashmap 底层如何实现

hashmap 底层是由哈希表进行插入和删除以及遍历。哈希表 是由数组+链表组成

数组 查询方便，插入删除麻烦； 链表 插入删除方便，查询麻烦 。哈希表则可以查询插入删除都方便

HashMap里面实现一个静态内部类 Entry ，其重要的属性有   key , value, next

// 存储时:

int  hash  =  key.hashCode();  //

int  index  =  hash  %  Entry[].length;

Entry[index]  =  value;

相同index的元素用next连接

========================

如何防止SQL注入

最终方案,参数绑定,preparedstatement 其在预处理阶段已经把SQL编译好，

preparedstatement 底层实现就是把传过来的SQL进行替换 不如#{id} 替换成 ？ 最后把各个字符串用append拼接起来

========================

CSS中 大于号的作用

功能类似于空格的作用，IE6不支持

=============================

spring如何来调用类

方法一： 在初始化时保存ApplicationContext对象

spring 首先是要配置applicationContext.xml

然后利用 ApplicationContext的主要实现类是ClassPathXmlApplicationContext和FileSystemXmlApplicationContext，加载该文件，利用单例模式获取到beanid

public class BeanManager {

private static ApplicationContext context = new ClassPathXmlApplicationContext( "appcontext.xml" ) ;

public static Object getBean(String beanId) {

return context.getBean(beanId);

}

}

在 web.xml 中写一个 servlet ，自动启动， init 方法中调用一下 BeanManager

方法二：继承自抽象类ApplicationObjectSupport

说明：抽象类ApplicationObjectSupport提供getApplicationContext()方法，可以方便的获取到ApplicationContext。Spring初始化时，会通过该抽象类的setApplicationContext(ApplicationContext context)方法将ApplicationContext 对象注入。

http://www.jb51.net/article/77794.htm

=============================

having和group by区别

group by 用于分组，select中非聚合函数的字段都必须出现在group by 后

having 对条件进行过滤，一般是对分组后的数据进行筛选，且条件可以是组函数

SELECT region, SUM(population), SUM(area) FROM bbc GROUP BY region

SELECT region, SUM(population), SUM(area) FROM bbc GROUP BY region HAVING SUM(area)>1000000==============================

数据库索引类型

建立索引可以加快检索速度

唯一性索引 建索引字段是唯一性非重复的；

主键索引 建索引列是主键

聚集索引 在聚集索引中，表中行的物理顺序与键值的逻辑（索引）顺序相同。一个表只能包含一个聚集索引。如字典默认按字母顺序排序，读者如知道某个字的读音可根据字母顺序快速定位

创建索引

CREATE INDEX index_name ON table_name (column_list)

删除索引

DROP INDEX index_name ON table_name

==============================

margin border padding 几者的顺序

从内到外 margin border padding

margin和border影响都是对外的，就是说，在里面的表不会因为这两个值而改变，padding是影响对内的

http://blog.csdn.net/u013488649/article/details/41040291

================================

session 和cookies

http://jingyan.baidu.com/article/ff411625cbb20c12e4823701.html

cookie 客户端浏览器中生成

    Cookie c1= new Cookie("USERNAME",logindto.getUsername());

//从客户端读取硬盘中的cookie文件

     Cookie[] cookies = request.getCookies();

for (int i = 0; i < cookies.length; i++){ //从客户端硬盘中读取你当前点击的

//页面的cookie

                 if ("USERNAME".equalsIgnoreCase(cookies[i].getName())){

                   username = cookies[i].getValue();

               }

session 服务器端生成

session机制是一种服务器端的机制

程序需要为某个客户端的请求创建一个session的时候，服务器首先检查这个客户端的请求里是否包含了一个session标识－称为session id，如果已经包含一个session id则说明以前已经为此客户创建过session，服务器就按照session id把这个session检索出来使用(如果检索不到，可能会新建一个，

String sessionId=request.getSession().getId();

首先要获得request对象，然后调用getSession()方法。

================================

mybatis #$ $为什么不能防止SQL注入

mybatis 是个半自动化持久层框架，SQL都要手动编写，所以要防止SQL注入

#{id} 底层会调用 PreparedStatement，PreparedStatement 是预编译，我们在调用该SQL进行查询的时候已经语句编译好了，mybatis会把 #{id} 编译为 一个问号？，后续程序再对该问号进行赋值；

而对于${id},我们在调用该SQL进行查询的时候语句还没有编译好，是在预编译的时候赋值，比如为5，则直接把${id} 转换为5，然后拼成一个完整的SQL，如果#{id} 也可以赋值为表的其他字段的字段名，比如name，然后拼成一个完整的SQL，这样就是SQL注入，程序出现BUG。但是程序涉及到动态表名列名时，只能用$,但是其他情况能尽量用#就不用$

http://www.myexception.cn/sql/1938757.html

================================

函数闭包

函数内在包含子函数，并return子函数

函数闭包的功能是实现数据缓存，子函数可以直接使用访问闭包函数定义的变量。

闭包函数常见的一种用途就是，我们可以通过此实现计数功能。

实现封装 子函数可以访问的局部变量，其他函数无法访问。

http://www.cnblogs.com/leoin2012/p/3978979.html

================================

DOM级节点: DOM级节点是html里面那些元素标签

================================

定时服务如何配置

转载 http://blog.csdn.net/heyutao007/article/details/38797335

Timer myTimer = new Timer();  

        myTimer.schedule(new Worker(), 1000);//1秒后执行  

Timer对调度的支持是基于绝对时间,而不是相对时间的，由此任务对系统时钟的改变是敏感的

ScheduledThreadExecutor只支持相对时间

每天晚上23:59对系统一天的订单进行批处理

ScheduledThreadExecutor是一个接口，总共有四个方法

/*** Eclipse Class Decompiler plugin, copyright (c) 2016 Chen Chao (cnfree2000@hotmail.com) ***/

package java.util.concurrent;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.ScheduledFuture;

import java.util.concurrent.TimeUnit;

public interface ScheduledExecutorService extends ExecutorService {

ScheduledFuture<?> schedule(Runnable arg0, long arg1, TimeUnit arg3);

<V> ScheduledFuture<V> schedule(Callable<V> arg0, long arg1, TimeUnit arg3);

ScheduledFuture<?> scheduleAtFixedRate(Runnable arg0, long arg1, long arg3, TimeUnit arg5);

ScheduledFuture<?> scheduleWithFixedDelay(Runnable arg0, long arg1, long arg3, TimeUnit arg5);

}

周期定时执行某个任务。

有时候我们希望一个任务被安排在凌晨3点（访问较少时）周期性的执行一个比较耗费资源的任务，可以使用下面方法设定每天在固定时间执行一次任务。

[java]  view plain  copy

1.   

[java]  view plain  copy

1. package test;  
2.   
3.   
4. import java.text.DateFormat;  
5. import java.text.SimpleDateFormat;  
6. import java.util.Date;  
7. import java.util.concurrent.*;  
8. import com.sun.org.apache.xerces.internal.impl.xpath.regex.ParseException;  
9. /**  
10.  * 每天晚上8点执行一次 ，输出语句 测试定时 ，而对于该定时程序会一直运行 
11.  * 每天定时安排任务进行执行  
12.  * @throws java.text.ParseException  
13.  */    
14.   
15. public class test2  {  
16.     public static void main(String[] args) {  
17.         test2 tt=new test2();  
18.         try {  
19.             tt.executeEightAtNightPerDay();  
20.         } catch (java.text.ParseException e) {  
21.             // TODO Auto-generated catch block  
22.             e.printStackTrace();  
23.         }  
24.     }  
25.   
26.     /**  
27.      * 每天晚上8点执行一次  
28.      * 每天定时安排任务进行执行  
29.      * 四个参数分别为 Runnable线程，当天的起始时间，间隔时间，时间单位 
30.      * initDelay时间可以随时修改来进行测试 
31.      * @throws java.text.ParseException  
32.      */    
33.     public static void executeEightAtNightPerDay() throws java.text.ParseException {    
34.         ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);    
35.         long oneDay = 24 * 60 * 60 * 1000;    
36.         long initDelay  = getTimeMillis("20:00:00") - System.currentTimeMillis();    
37.         initDelay = initDelay > 0 ? initDelay : oneDay + initDelay;    
38.         
39.         executor.scheduleAtFixedRate(    
40.                 new ThreadTest1(),    
41.                 initDelay,    
42.                 oneDay,    
43.                 TimeUnit.MILLISECONDS);    
44.     }    
45.       
46.     /**  
47.      * 获取指定时间对应的毫秒数  
48.      * @param time "HH:mm:ss"  
49.      * @return  
50.      * @throws java.text.ParseException  
51.      */    
52.     private static long getTimeMillis(String time) throws java.text.ParseException {    
53.         try {    
54.             DateFormat dateFormat = new SimpleDateFormat("yy-MM-dd HH:mm:ss");    
55.             DateFormat dayFormat = new SimpleDateFormat("yy-MM-dd");    
56.             Date curDate = dateFormat.parse(dayFormat.format(new Date()) + " " + time);    
57.             return curDate.getTime();    
58.         } catch (ParseException e) {    
59.             e.printStackTrace();    
60.         }    
61.         return 0;    
62.     }   
63. }  
64. class ThreadTest1 implements Runnable{     
65.     //定义ThreadTest1的同步方法    
66.     //定时在规定的时间点，输入语句 测试定时   
67.     public synchronized void run(){//重写Runnable接口的run(),并声明成synchronized    
68.         System.out.println("测试定时");  
69.     }  
70.       
71. }  

========================

spring如何自定义标签

假设自定义标签 A ，首先创建对象A,然后在创建相对应的解析类 AParser

然后再定义处理类 Ahander ，其功能主要是用来调用 解析类 AParser ,最后再创建xsd文件用来校验我们创建的自定义标签有效性

spring 读取自定义的schema和handler 默认是根据spring handler和 spring schema来读取

http://blog.csdn.net/sonycong/article/details/52386783

========================

单例模式 分为饿汉式和懒汉式

========================

单例多例模式区别

1. 什么是单例多例；

2. 如何产生单例多例；

3. 为什么要用单例多例

4. 什么时候用单例，什么时候用多例；

1. 什么是单例多例:

所谓单例就是所有的请求都用一个对象来处理，比如我们常用的service和dao层的对象通常都是单例的，而多例则指每个请求用一个新的对象来处理，比如action; 

2. 如何产生单例多例:

    在通用的SSH中，单例在spring中是默认的，如果要产生多例，则在配置文件的bean中添加scope="prototype"; 

3. 为什么用单例多例：

    之所以用单例，是因为没必要每个请求都新建一个对象，这样子既浪费CPU又浪费内存；

   之所以用多例，是为了防止并发问题；即一个请求改变了对象的状态，此时对象又处理另一个请求，而之前请求对对象状态的改变导致了对象对另一个请求做了错误的处理；

    用单例和多例的标准只有一个：

    当对象含有可改变的状态时（更精确的说就是在实际应用中该状态会改变），则多例，否则单例；

4. 何时用单例？何时用多例？

    对于struts2来说，action必须用多例，因为action本身含有请求参数的值，即可改变的状态；

  而对于STRUTS1来说，action则可用单例，因为请求参数的值是放在actionForm中，而非action中的；

   另外要说一下，并不是说service或dao一定是单例，标准同第3点所讲的，就曾见过有的service中也包含了可改变的状态，同时执行方法也依赖该状态，但一样用的单例，这样就会出现隐藏的BUG,而并发的BUG通常很难重现和查找；

5. 多例模式如何创建对象

一个有上限的多例类可以使用静态变量存储所有的实例，特别是在实例数目不多的时候，可以使用一个个静态变量存储一个个的实例  private static Die die1,die2;  

在数目较多的时候，就需要使用静态聚集来存储这些实例

========================

组成JSON字符串

JSONObject 是JSON对象，利用element方法添加JSON节点；

JSONArray利用add方法添加json对象JSONObject

解析JSON字符串

================================

JVM机制

JVM包含 类加载子系统，运行数据区，执行引擎 三部分

类加载器子系统 Java类的加载，链接，初始化。在java类加载时，而非编译时。

加载 是按规定好的文件路径顺序加载jar包，加载类

链接 对前面一步加载生成的字节码文件是否正确

初始化 静态变量赋予原始值，并且执行静态代码块

运行数据区

运行数据区分为5个组件：方法区，堆区域，堆栈区，PC寄存器，本地方法堆栈

方法区：类级别的数据存储在这里 。方法区里存的都是类型信息，也就是类的信息，而类的信息 又包括以下内容： 类的全限定名(类的全路径名) 

    类的直接超类的全限定名(如果这个类是Object,则它没有超类) 

    这个类是类型(类)还是接口 

     类的访问修饰符,如public、abstract、final等 

     所有的直接接口全限定名的有序列表(假如它实现了多个接口) 

     常量池 

     字段、方法信息、类变量信息(静态变量)   

装载该类的装载器的引用(classLoader)、

类型引用(class)

堆区域： 所有对象及其对应的实例变量和数组将存储在这里

JVM中只有一个方法区，一个堆区域，是共享资源。方法区是线程安全的，堆区域是线程非安全的。

堆栈区 对于每个线程都将新创建一个栈，对于每个方法的调用，将在堆栈存储器中产生一个条目，称为堆栈帧。所有局部变量将在堆栈内存中创建。