java知识点

一、面向对象的五大基本原则： 
1.单一职责原则（Single-Resposibility Principle）：一个类，最好只做一件事，只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。 
2.开放封闭原则（Open-Closed principle）：软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。 
3.Liskov替换原则（Liskov-Substituion Principle）：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。 
4.依赖倒置原则（Dependecy-Inversion Principle）：依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。 
5.接口隔离原则（Interface-Segregation Principle）：使用多个小的专门的接口，而不要使用一个大的总接口。

二、jdk的bin文件

jar         将许多文件组合成一个jar文件

javac      编译

javadoc  它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。

javah     把java代码声明的JNI方法转化成C\C++头文件。 JNI可参考java核心技术卷二第12章。

三、堆、栈以及valueof方法

Integer i01=59 的时候，会调用 Integer 的 valueOf 方法，

1 2 3 4 5

public static Integer valueOf( int i) {       assert IntegerCache.high>=  127 ;       if (i >= IntegerCache.low&& i <= IntegerCache.high)       return IntegerCache.cache[i+ (-IntegerCache.low)];       return new Integer(i); }

这个方法就是返回一个 Integer 对象，只是在返回之前，看作了一个判断，判断当前 i 的值是否在 [-128,127] 区别，且 IntegerCache 中是否存在此对象，如果存在，则直接返回引用，否则，创建一个新的对象。在这里的话，因为程序初次运行，没有 59 ，所以，直接创建了一个新的对象。

int i02=59 ，这是一个基本类型，存储在栈中。

Integer i03 =Integer.valueOf(59); 因为 IntegerCache 中已经存在此对象，所以，直接返回引用。

Integer i04 = new Integer(59) ；直接创建一个新的对象。

System. out .println(i01== i02); i01 是 Integer 对象， i02 是 int ，这里比较的不是地址，而是值。 Integer 会自动拆箱成 int ，然后进行值的比较。所以，为真。

System. out .println(i01== i03); 因为 i03 返回的是 i01 的引用，所以，为真。

System. out .println(i03==i04); 因为 i04 是重新创建的对象，所以 i03,i04 是指向不同的对象，因此比较结果为假。

System. out .println(i02== i04); 因为 i02 是基本类型，所以此时 i04 会自动拆箱，进行值比较，所以，结果为真。

四、String类的特点

第一次String a="1234"时，会在常量池中创建一个常量1234,String b="1234"时，常量池中已经有了该常量，所以直接取，a和b的地址一样，所以地址值相等；String c = newString("1234")重新new了对象，在堆内存中开辟了新的空间，所以地址值不想等。而equals方法比较的是 值是否相等。

五、java包装类有哪些

Boolean Byte Short Integer Long Float Double Character

六、jvm中垃圾回收分为scanvenge gc和full GC。

full GC触发的条件：

除直接调用System.gc外，触发Full GC执行的情况有如下四种。
1. 旧生代空间不足
旧生代空间只有在新生代对象转入及创建为大对象、大数组时才会出现不足的现象，当执行Full GC后空间仍然不足，则抛出如下错误：
java.lang.OutOfMemoryError: Java heap space 
为避免以上两种状况引起的FullGC，调优时应尽量做到让对象在Minor GC阶段被回收、让对象在新生代多存活一段时间及不要创建过大的对象及数组。
2. Permanet Generation空间满
PermanetGeneration中存放的为一些class的信息等，当系统中要加载的类、反射的类和调用的方法较多时，Permanet Generation可能会被占满，在未配置为采用CMS GC的情况下会执行Full GC。如果经过Full GC仍然回收不了，那么JVM会抛出如下错误信息：
java.lang.OutOfMemoryError: PermGen space 
为避免Perm Gen占满造成Full GC现象，可采用的方法为增大Perm Gen空间或转为使用CMS GC。
3. CMS GC时出现promotion failed和concurrent mode failure
对于采用CMS进行旧生代GC的程序而言，尤其要注意GC日志中是否有promotion failed和concurrent mode failure两种状况，当这两种状况出现时可能会触发Full GC。
promotionfailed是在进行Minor GC时，survivor space放不下、对象只能放入旧生代，而此时旧生代也放不下造成的；concurrent mode failure是在执行CMS GC的过程中同时有对象要放入旧生代，而此时旧生代空间不足造成的。
应对措施为：增大survivorspace、旧生代空间或调低触发并发GC的比率，但在JDK 5.0+、6.0+的版本中有可能会由于JDK的bug29导致CMS在remark完毕后很久才触发sweeping动作。对于这种状况，可通过设置-XX:CMSMaxAbortablePrecleanTime=5（单位为ms）来避免。
4. 统计得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间
这是一个较为复杂的触发情况，Hotspot为了避免由于新生代对象晋升到旧生代导致旧生代空间不足的现象，在进行Minor GC时，做了一个判断，如果之前统计所得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间，那么就直接触发Full GC。
例如程序第一次触发MinorGC后，有6MB的对象晋升到旧生代，那么当下一次Minor GC发生时，首先检查旧生代的剩余空间是否大于6MB，如果小于6MB，则执行Full GC。
当新生代采用PSGC时，方式稍有不同，PS GC是在Minor GC后也会检查，例如上面的例子中第一次Minor GC后，PS GC会检查此时旧生代的剩余空间是否大于6MB，如小于，则触发对旧生代的回收。
除了以上4种状况外，对于使用RMI来进行RPC或管理的Sun JDK应用而言，默认情况下会一小时执行一次Full GC。可通过在启动时通过- java-Dsun.rmi.dgc.client.gcInterval=3600000来设置Full GC执行的间隔时间或通过-XX:+ DisableExplicitGC来禁止RMI调用System.gc。

1，新生代：（1）所有对象创建在新生代的Eden区，当Eden区满后触发新生代的Minor GC，将Eden区和非空闲Survivor区存活的对象复制到另外一个空闲的Survivor区中。（2）保证一个Survivor区是空的，新生代Minor GC就是在两个Survivor区之间相互复制存活对象，直到Survivor区满为止。
2，老年代：当Survivor区也满了之后就通过Minor GC将对象复制到老年代。老年代也满了的话，就将处罚Full GC，针对整个堆（包括新生代、老年代、持久代）进行垃圾回收。
3，持久代：持久代如果满了，将处罚Full GC。

七、String/StringBuffer/StringBuilder

String(大姐，出生于JDK1.0时代) 不可变字符序列     <StringBuffer(二姐，出生于JDK1.0时代)  线程安全的可变字符序列   <StringBuilder(小妹，出生于JDK1.5时代) 非线程安全的可变字符序列 。

Java中的String是一个类，而并非基本数据类型。string是值传入，不是引用传入。

 StringBuffer和StringBuilder可以算是双胞胎了，这两者的方法没有很大区别。但在线程安全性方面，StringBuffer允许多线程进行字符操作。 这是因为在源代码中StringBuffer的很多方法都被关键字 synchronized  修饰了，而StringBuilder没有。StringBuilder的效率比StringBuffer稍高，如果不考虑线程安全，StringBuilder应该是首选。

另外，JVM运行程序主要的时间耗费是在创建对象和回收对象上。对String类型进行改变的时候其实都等同于生成了一个新的  String  对象，然后将指针指向新的  String  对象，而不是StringBuffer；StringBuffer每次结果都会对  StringBuffer  对象本身进行操作，而不是生成新的对象，再改变对象引用。

String S1 = “This is only a” + “ simple” + “ test” ;在编译的时候S1就是常量了可以理解为  String S1 = “This is only a simple test” ; ，不存在运行时对字符串的处理，所以效率最高。

八、本题是一个自动拆装箱的考题(自动拆装箱JDK需在1.5上）
1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
2、两个Integer类型进行“==”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

九、代码块执行顺序

静态块：用static申明，JVM加载类时执行，仅执行一次
构造块：类中直接用{}定义，每一次创建对象时执行
执行顺序优先级：静态块>main()>构造块>构造方法
静态块按照申明顺序执行，所以先执行publicstaticB t1 = newB();该语句创建对象，则又会调用构造块，输出构造块
接着执行public static B t1 = new B();输出构造块
再执行
static
{
System.out.println("静态块");
}输出静态块
最后main方法执行，创建对象，输出构造块。

十、redirect/forward

redirect：请求重定向：客户端行为，本质上为2次请求，地址栏改变，前一次请求对象消失。举例：你去银行办事（forward.jsp），结果告诉你少带了东西，你得先去公安局办(index.html)临时身份证,这时你就会走出银行，自己前往公安局，地址栏变为index.html。
forward：请求转发:服务器行为，地址栏不变。举例：你把钱包落在出租车上，你去警察局（forward.jsp）报案，警察局说钱包落在某某公司的出租车上（index.html)，这时你不用亲自去找某某公司的出租车,警察局让出租车自己给你送来，你只要在警察局等就行。所以地址栏不变，依然为forward.jsp。

 十一、继承类的方法调用顺序 （ 主要是记住父类执行时得执行子类重写的方法 ）

① 子类B中重写了父类A中的setValue方法

super(5) //调用了父类构造器，其中构造函数里面的setValue(value),调用的是子类的setValue方法

finally块中的

this.setValue(value) //调用的也是子类的setValue方法

而子类setValue方法中的

super.setValue(2*value); //调用的是父类A的setValue方法

② try...catch...finally块中有return返回值的情况：finally块中虽然改变了value的值，但try块中返回的应该是return返回之前存储的值。

十二、HttpServletResponse完成的功能

A：设置HTTP头标  

1	response.setHeader( "Refresh" , "3" );  //三秒刷新页面一次

B：设置cookie

1 2	Cookie c1 =  new Cookie( "username" , "only" ); response.addCookie(c1);

C（错误）：读取路径信息,request读取路径信息

1 2 3 4 5

从request获取各种路径总结 request.getRealPath( "url" );  // 虚拟目录映射为实际目录 request.getRealPath( "./" );     // 网页所在的目录 request.getRealPath( "../" );  // 网页所在目录的上一层目录 request.getContextPath();     // 应用的web目录的名称

 

D：输出返回数据

1	HttpServleteResponse.getOutputStream().write();

十三、正则表达式

由于replaceAll方法的第一个参数是一个正则表达式，而"."在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成"/"。如果想替换的只是"."，那么久要写成"\\."。

十四、重载的概念是：

方法名称相同，参数个数、次序、类型不同

因此重载对返回值没有要求，可以相同，也可以不同

但是如果参数的个数、类型、次序都相同，方法名也相同，仅返回值不同，则无法构成重载

十五、final类

1.final修饰变量，则等同于常量

2.final修饰方法中的参数，称为最终参数。

3.final修饰类，则类不能被继承

4.final修饰方法，则方法不能被重写。

A: 接口和抽象类不能是final的，它们需要被实现和继承

C: 重载和重写要区分开，父子之间是重写，同一个类里面是重载，final修饰的子类没法重写，而不是重载。

十六、单元测试

mock对象：也成为伪对象，在测试中的利用mock对象来代替真实对象，方便测试的进行。

java的封装性：指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，通过该类提供的方法实现对内部信息的操作访问。

反射机制：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意一个方法和属性。

反射可以访问原类的私有方法，私有成员变量，因此，反射破坏了Java的封装性。

反射破坏代码的封装性，破坏原有的访问修饰符访问限制。

十七、变量

类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。

boolean 类型默认值是 false。

十八、垃圾回收

当程序运行时，至少会有两个线程开启启动，一个是我们的主线程（main()函数），一个是垃圾回收线程，垃圾回收线程的priority（优先级）较低。
垃圾回收器会对我们使用的对象进行监视，当一个对象长时间不使用时，垃圾回收器会在空闲的时候（不定时）对对象进行回收，释放内存空间，程序员是不可以显示的调用垃圾回收器回收内存的，但是可以使用System.gc()方法建议垃圾回收器进行回收，但是垃圾回收器不一定会执行。垃圾收集器（GC）程序开发者只能推荐JVM进行回收，但何时回收，回收哪些，程序员不能控制。
Java的垃圾回收机制可以有效的防止内存溢出问题，但是它并不能完全保证不会出现内存溢出。例如当程序出现严重的问题时，也可能出现内存溢出问题。

进入DEAD的线程，它还可以恢复，GC不会回收。

在《java虚拟机》一书中明确讲了，释放掉占据的内存空间是由gc完成，但是程序员无法明确强制其运行，该空间在不被引用的时候不一定会立即被释放，这取决于GC本身，无法由程序员通过代码控制。

Java 把内存划分成两种：一种是栈内存，另一种是堆内存。
在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，当在一段代码块定义一个变量时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。
数组和对象在没有引用变量指向它的时候，才变为垃圾，不能再被使用，但仍然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉）。这也是 Java 比较占内存的原因。

十九、JAVA反射机制概念：

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

Java反射机制主要提供了以下功能： 
    在运行时判断任意一个对象所属的类；
    在运行时构造任意一个类的对象；
    在运行时判断任意一个类所具有的成员变量和方法；
    在运行时调用任意一个对象的方法；
    生成动态代理。

二十、java和c++比较

JAVA没有指针的概念，被封装起来了，而C++有;JAVA不支持类的多继承，但支持接口多继承，C++支持类的多继承;C++支持操作符重载，JAVA不支持;JAVA的内存管理比C++方便，而且错误处理也比较好;C++的速度比JAVA快。
C++更适用于有运行效率要求的情况，JAVA适用于效率要求不高，但维护性要好的情况。

JAVA不使用指针，不支持头文件，不支持宏定义，JAVA可以动态分配内存

C++比较适合一些底层处理，JAVA比较适合开发应用，可以是WEB，也可以是手机端的Android。

二十一、抽象类和接口

总结：接口所有方法全是抽象方法只能 public abstract修饰 （默认public abstract修饰 ），属性默认public static final修饰。

        抽象类除了包含抽象方法外与普通类无区别。 

二十二、JVM 将内存区域划分为：

大多数 JVM 将内存区域划分为 Method Area（Non-Heap）（方法区） ,Heap（堆） , Program Counter Register（程序计数器） ,   VM Stack（虚拟机栈，也有翻译成JAVA 方法栈的）,Native Method Stack  （ 本地方法栈 ），其中Method Area方法区 和 Heap堆 是线程共享的  ，VM Stack，Native Method Stack  和Program Counter Register  是非线程共享的。在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。

首先我们熟悉一下一个一般性的 Java 程序的工作过程。一个 Java 源程序文件，会被编译为字节码文件（以 class 为扩展名），每个java程序都需要运行在自己的JVM上，然后告知 JVM 程序的运行入口，再被 JVM 通过字节码解释器加载运行。那么程序开始运行后，都是如何涉及到各内存区域的呢？

概括地说来，JVM初始运行的时候都会分配好 Method Area（方法区） 和Heap（堆） ，而JVM 每遇到一个线程，就为其分配一个 Program Counter Register（程序计数器） ,   VM Stack（虚拟机栈）和Native Method Stack  （本地方法栈）， 当线程终止时，三者（虚拟机栈，本地方法栈和程序计数器）所占用的内存空间也会被释放掉。这也是为什么我把内存区域分为线程共享和非线程共享的原因，非线程共享的那三个区域的生命周期与所属线程相同，而线程共享的区域与JAVA程序运行的生命周期相同，所以这也是系统垃圾回收的场所只发生在线程共享的区域（实际上对大部分虚拟机来说知发生在Heap上）的原因。

二十三、SPRING的事务传播特性

 

转载于:https://www.cnblogs.com/java-xu/p/6188368.html