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，事实上原理非常easy，就是对你返回的实例进行包装，把这个实例的每一个方法前中后增加方法，
在这里没有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（责任链模式）
工厂模式：工厂模式是一种常常被使用到的模式。依据工厂模式实现的类能够依据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类而且实现了同样的方法，可是这些方法针对不同的数据进行了不同的操作。首先须要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后须要定义一个工厂类，工厂类能够依据条件生成不同的子类实例。当得到子类的实例后。开发者能够调用基类中的方法而不必考虑究竟返回的是哪一个子类的实例。