java 面试总结

1、static变量与实体变量的区别？
static是静态变量，static可以通过类名直接访问
内存方面的不同：static在定义的时候jvm就会分配空间，
而实体变量只有在创建对象的时候才会去分配空间

2、int Integer的区别？
Integer 是int的包装类。
Integer 是对象，默认为null,int 的默认值是0

3、public protected friendly private 之间的区别？
当前类 同一包 继承类 不同包
public √ ok ok ok
protected √ ok ok no
friendly √ ok no no
private √ no no no

4、重载与重写的区别？
overload重载：方法名称相同，参数不同
overwrite重写：父类方法的重新写

5、数据库分页查询
oracle:select * from (select * from table where romnum >0) where romnum <20;
mysql:select * from table limit 0,20

6、webservice ？
企业发布的服务能够通过internet访问并且调用的现在服务。
实现服务的硬件平台、操作系统和编程语言
主要构成有wsdl:web服务描述语言

7、SOA的特点？
可重用
松耦合

8、webservice
JAX-WS
CXF

9、抽象类与普通类的区别：
抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法；

10、抽象类与接口的区别：
abstract class和interface是Java语言中的两种定义抽象类的方式，它们之间有很大的相似性。
但是对于它们的选择却又往往反映出对于问题领域中的概 念本质的理解、对于设计意图的反映是否正确、
合理，因为它们表现了概念间的不同的关系（虽然都能够实现需求的功能）。
这其实也是语言的一种的惯用法。
总结几句话来说：
抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，
接口变量必须指向实现所有接口方法的类对象。
抽象类要被子类继承，接口要被类实现。
接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。
同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
抽象方法只能申明，不能实现。abstract void abc();不能写成abstract void abc(){}。
抽象类里可以没有抽象方法
如果一个类里有抽象方法，那么这个类只能是抽象类
抽象方法要被实现，所以不能是静态的，也不能是私有的。
接口可继承接口，并可多继承接口，但类只能单根继承。

控制反转：要消除应用程序对插件实现的依赖，依赖注入并不是唯一的选择
IOC：依赖注入：依赖注入的形式主要有三种，
我分别将它们叫做构造函数注入（Constructor Injection）、
设值方法注入（Setter Injection）
和接口注入（Interface Injection）。
如果读过最近关于IoC的一些讨论材料，你不难看出：
这三种注入形式分别就是type 1 IoC（接口注入）、type 2 IoC（设值方法注入）和type 3 IoC（构造函数注入）。

所谓AOP，即Aspect orientied program,就是面向方面的编程，
2.解释什么是方面：贯穿到系统的各个模块中的系统一个功能就是一个方面，
比如，记录日志，统一异常处理，事务处理，全限检查，这些功能都是软件系统
的一个面，而不是一点，在各个模块中都要出现。
3.什么是面向方面编程：把系统的一个方面的功能封装成对象的形式来处理
4.怎么进行面向方面编程：把功能模块对应的对象作为切面嵌入到原来的各个系统模块中，
采用代理技术，代理会调用目标，同时把切面功能的代码（对象）加入进来，所以，
用spring配置代理对象时只要要配两个属性，分别表示目标和切面对象（Advisor）。

Ioc就是实例接口或者实例类交给IOC容器去做（如果把工厂模式理解成一个IOC也没什么问题）

AOP就是织入技术，说白了，想实现的效果就是在方法执行前，执行中，执行后动态插入方法
首先说AOP，其实原理很简单，就是对你返回的实例进行包装，把这个实例的每个方法前中后加入方法，
在这里没有IOC的话，那么这个实现就会对程序员暴露出来，在加入IOC后，就完美了
流程就是，IOC去实例对象，在实例的时候再调用AOP的程序对这个对象再包装，
返回给编程人员的最终对象就是经过包装后的对象了，就这么简单。至于怎么实现，有很多方法
最典型的就是Sprint.net,它是用反射中Emit实现的

IOC:控制反转也叫依赖注入。利用了工厂模式
将对象交给容器管理，你只需要在spring配置文件总配置相应的bean，以及设置相关的属性，让spring容器来生成类的实例对象以及管理对象。在spring容器启动的时候，spring会把你在配置文件中配置的bean都初始化好，然后在你需要调用的时候，就把它已经初始化好的那些bean分配给你需要调用这些bean的类（假设这个类名是A），分配的方法就是调用A的setter方法来注入，而不需要你在A里面new这些bean了。
注意：面试的时候，如果有条件，画图，这样更加显得你懂了
AOP:面向切面编程。（Aspect-Oriented Programming）
AOP可以说是对OOP的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。
将程序中的交叉业务逻辑（比如安全，日志，事务等），封装成一个切面，然后注入到目标对象（具体业务逻辑）中去。

实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码
简单点解释，比方说你想在你的biz层所有类中都加上一个打印‘你好’的功能这你经可以用aop思想来做，你先写个类写个方法，方法经实现打印‘你好’让后你Ioc这个类 ref＝“biz.*”让每个类都注入。

数据库各种连接区别：
left join,right join,inner join(join)
left join与right join之间是相对的：
基本的例子：select * from table1 t1 left join table2 t2 on t1.col1 = t2.col2;
这个时候查出来的结果是：table1 的全部集合，table2的部分集合
如果想查找table2的全部集合：则可以使用right join:
select * from table1 t1 right join table2 t2 on t1.col1 = t2.col2;
inner join 与join是完全相同的，查找的是两个表的交集。
select * from table1 t1 inner join table2 t2 on t1.col1 = t2.table2 where t1.id = 1;

基本数据类型包括byte、int、char、long、float、double、boolean和short。
九大封装类：Byte,Integer，Char,Long,Float,Double,Boolean,Short,String;

线程的实现方式：
继承Thread类，实现Runnable接口，通过线程池的方式去实现

sleep(),wait()方法的区别：
sleep() 当前线程暂停执行，让出CPU资源给其他的线程去执行，监控状态依然不变，但是sleep()不会放弃对象锁。
wait() 当前线程放弃对象锁，进入等待状态，只有在notify的时候才能被唤醒，
但是sleep(),在线程执行完之后会立刻进入执行状态。

java 基本类型与封装类的区别
1.基本类型只能按值传递，而每个基本类型对应的封装类是按引用传递的。
2.从性能上说java中的基本类型是在栈上创建的，而所有的对象类型都是在堆上创建的，（对象的引用在栈上创建）。
3.封装类的出现，是为了更方便的使用一些基本类型不具备的方法，比如valueOf（），toString（）等等。
4.如果想传递一个int对象的引用，而不是值，那只能用封装类。
5.基本数据可以自动封装成封装类,基本数据类型的好处就是速度快（不涉及到对象的构造和回收），封装类的目的主要是更好的处理数据之间的转换，方法很多，用起来也方便。

[在栈上分配内存的调用效率和在堆上分配内存的效率差太多了。虽然在栈上分配内存效率高，不过在栈上分配内存有内存泄露的问题。]

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（责任链模式）
工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。