摩根Java面试准备要点.docx
《摩根Java面试准备要点.docx》由会员分享，可在线阅读，更多相关《摩根Java面试准备要点.docx（21页珍藏版）》请在冰豆网上搜索。
摩根Java面试准备要点
摩根Java面试准备要点
观察以上的输出，除了发现两个业务方法中都织入了性能监控的逻辑外，我们还发现代理类的名字是com.baobaotao.proxy.ForumServiceImpl$$EnhancerByCGLIB$$2a9199c0，这个特殊的类就是CGLib为ForumServiceImpl所动态创建的子类。
小结
SpringAOP在底层就是利用JDK动态代理或CGLib动态代理技术为目标Bean织入横切逻辑。
在这里，我们对以上两节动态创建代理对象做一个小结。
在PerformaceHandler和CglibProxy中，有三点值得注意的地方是：
第一，目标类的所有方法都被添加了性能监视横切的代码，而有时，这并不是我们所期望的，我们可能只希望对业务类中的某些方法织入横切代码；第二，我们手工指定了织入横切代码的织入点，即在目标类业务方法的开始和结束前调用；第三，我们手工编写横切代码。
以上三个问题，在AOP中占用重要的地位，因为SpringAOP的主要工作就是围绕以上三点展开：
SpringAOP通过Pointcut（切点）指定在哪些类的哪些方法上施加横切逻辑，通过Advice（增强）描述横切逻辑和方法的具体织入点（方法前、方法后、方法的两端等），此外，Spring还通过Advisor（切面）组合Pointcut和Advice。
有了Advisor的信息，Spring就可以利用JDK或CGLib的动态代理技术为目标Bean创建织入切面的代理对象了。
JDK动态代理所创建的代理对象，在JDK1.3下，性能强差人意。
虽然在高版本的JDK中，动态代理对象的性能得到了很大的提高，但是有研究表明，CGLib所创建的动态代理对象的性能依旧比JDK的所创建的代理对象的性能高不少（大概10倍）。
而CGLib在创建代理对象时性能却比JDK动态代理慢很多（大概8倍），所以对于singleton的代理对象或者具有实例池的代理，因为不需要频繁创建代理对象，所以比较适合用CGLib动态代理技术，反之适合用JDK动态代理技术。
此外，由于CGLib采用生成子类的技术创建代理对象，所以不能对目标类中的final方法进行代理。
JavaString
Java代码Strings=newString（abc）;
Strings1=abc
Strings2=newString（abc）;
System.out.println（s==s1）;
System.out.println（s==s2）;
System.out.println（s1==s2）;
Strings=newString（abc）;Strings1=abcStrings2=newString（abc）;System.out.println（s==s1）;System.out.println（s==s2）;System.out.println（s1==s2）;
请问以上程序执行结果是什么？
第一句执行后内存中有两个对象，而不是一个。
一个由newString（abc）中的abc在StringPool里生成一个值为abc的对象；第二个由new在堆里产生一个值为abc的对象，该对象完全是StringPool里的abc的一个拷贝。
变量s最后指向堆中产生的abc对象；
第二句执行时，s1先去StringPool找是否有值为abc的对象，很显然在上一步中java已经在StringPool里生成一个abc对象了，所以s1直接指向StringPool中的这个abc；
第三句中又有一个new，在java中凡遇到new时，都会在堆里产生一个新的对象。
因此，该句执行后堆里又多了一个abc对象，这与执行第一句后生成的abc是不同的两个对象，s2最后指向这个新生成的对象。
因此，执行后面的打印语句的结果是三个false
问题2:
Java代码System.out.println（s==s.intern（））;
System.out.println（s1==s1.intern（））;
System.out.println（s1.intern（）==s2.intern（））;
System.out.println（s==s.intern（））;System.out.println（s1==s1.intern（））;System.out.println（s1.intern（）==s2.intern（））;
请问以上程序执行结果是什么？
设s为String类型的变量，当执行s.intern（）时，java先在StringPool里找与字符串变量s相等（用equals（）方法）的字符串，若有则将其引用返回；若没有则在StringPool里创建一个与s的值相等的字符串对象，并将其引用返回。
从中我们可以总结出intern（）方法无论如何都将返回StringPool里的字符串对象的引用。
因此，以上程序执行的结果是false，true，true。
PS:
设s和t为两个字符串变量，若有s.equals（t），必有s.intern（）==t.intern（）；
PS:
==永远比较的是两边对象的地址是否相等。
问题3：
Java代码Stringhello=hello
Stringhel=hel
Stringlo=lo
System.out.println（hello==hel+lo）;
System.out.println（hello==hel+lo）;
Stringhello=helloStringhel=helStringlo=loSystem.out.println（hello==hel+lo）;System.out.println（hello==hel+lo）;
请问以上程序执行结果是什么？
前三句在StringPool里分别产生hello、hel、lo三个常量字符串对象
当做第一个加法连接时，+号两边都是常量字符串，java就会将两者拼起来后到StringPool里找与之相等（用equals）的字符串，若存在则将其地址返回；不存在则在StringPool里新建一个常量对象，其值等于拼接后的字符串，并将其地址返回。
第二个+号两边有一个是变量，此时，java会在堆里新建一个对象，其值是两字符串拼接后的值，此时返回的地址是堆中新对象的地址。
所以，第一句做+连接后返回StringPool中hello的地址，显然与变量hello的地址相等；
第二句返回的是堆中地址，显然与变量hello的地址不等；Java的String，StringBuffer，StringBuilder有什么区别？
那就是：
String是不可变类（immutable），每次在String对象上的操作都会生成一个新的对象；StringBuffer和StringBuilder则允许在原来对象上进行操作，而不用每次增加对象；StringBuffer是线程安全的，但效率较低，而StringBuilder则不是效率最高。
这个答案我是很早都知道的，而且实际应用中也是这样做的，经常变化的时候用StringBuilder或者StringBuffer。
但是为什么是这样的是最近才晓得的，而了解的方法非常简单，就是阅读jdk的源代码：
String和StringBuffer，StringBuilder都是用字符数组来表示的。
但是在String中这个字符数组是这样定义的：
/**Thevalueisusedforcharacterstorage.*/
privatefinalcharvalue[];
而在StringBuffer和StringBuilder中，这个字符数组都是继承于java.lang.AbstractStringBuilder中的
/**
*Thevalueisusedforcharacterstorage.
*/
charvalue[];
这样答案就很明显了，原因就在这个final关键字上。
而同时通过源代码可以发现StringBuffer的很多方法和属性都有synchronized关键字修饰，而StringBuilder则没有。
就是这样的，源代码胜过一切文档和专家老师的讲解。
JavaObject
方法摘要
protectedObjectclone（）
创建并返回此对象的一个副本。
booleanequals（Objectobj）
指示某个其他对象是否与此对象相等。
protectedvoidfinalize（）
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
ClassgetClass（）
返回一个对象的运行时类。
inthashCode（）
返回该对象的哈希码值。
voidnotify（）
唤醒在此对象监视器上等待的单个线程。
voidnotifyAll（）
唤醒在此对象监视器上等待的所有线程。
StringtoString（）
返回该对象的字符串表示。
voidwait（）
导致当前的线程等待，直到其他线程调用此对象的notify（）方法或notifyAll（）方法。
voidwait（longtimeout）
导致当前的线程等待，直到其他线程调用此对象的notify（）方法或notifyAll（）方法，或者超过指定的时间量。
voidwait（longtimeout,intnanos）
导致当前的线程等待，直到其他线程调用此对象的notify（）方法或notifyAll（）方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。
构造方法详细信息
Object
publicObject（）
方法详细信息
getClass
publicfinalClassgetClass（）
返回一个对象的运行时类。
该Class对象是由所表示类的staticsynchronized方法锁定的对象。
返回：
表示该对象的运行时类的java.lang.Class对象。
此结果属于类型Class，其中X表示清除表达式中的静态类型，该表达式调用getClass。
——————————————————————————–
hashCode
publicinthashCode（）
返回该对象的哈希码值。
支持该方法是为哈希表提供一些优点，例如，java.util.Hashtable提供的哈希表。
hashCode的常规协定是：
在Java应用程序执行期间，在同一对象上多次调用hashCode方法时，必须一致地返回相同的整数，前提是对象上equals比较中所用的信息没有被修改。
从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
如果根据equals（Object）方法，两个对象是相等的，那么在两个对象中的每个对象上调用hashCode方法都必须生成相同的整数结果。
以下情况不是必需的：
如果根据equals（java.lang.Object）方法，两个对象不相等，那么在两个对象中的任一对象上调用hashCode方法必定会生成不同的整数结果。
但是，程序员应该知道，为不相等的对象生成不同整数结果可以提高哈希表的性能。
实际上，由Object类定义的hashCode方法确实会针对不同的对象返回不同的整数。
（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是JavaTM编程语言不需要这种实现技巧。
）
返回：
此对象的一个哈希码值。
另请参见：
equals（java.lang.Object）,Hashtable
——————————————————————————–
equals
publicbooleanequals（Objectobj）
指示某个其他对象是否与此对象相等。
equals方法在非空对象引用上实现相等关系：
自反性：
对于任何非空引用值x，x.equals（x）都应返回true。
对称性：
对于任何非空引用值x和y，当且仅当y.equals（x）返回true时，x.equals（y）才应返回true。
传递性：
对于任何非空引用值x、y和z，如果x.equals（y）返回true，并且y.equals（z）返回true，那么x.equals（z）应返回true。
一致性：
对于任何非空引用值x和y，多次调用x.equals（y）始终返回true或始终返回false，前提是对象上equals比较中所用的信息没有被修改。
对于任何非空引用值x，x.equals（null）都应返回false。
Object类的equals方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值x和y，当且仅当x和y引用同一个对象时，此方法才返回true（x==y具有值true）。
注意：
当此方法被重写时，通常有必要重写hashCode方法，以维护hashCode方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
参数：
obj–要与之比较的引用对象。
返回：
如果此对象与obj参数相同，则返回true；否则返回false。
另请参见：
hashCode（）,Hashtable
——————————————————————————–
clone
protectedObjectclone（）
throwsCloneNotSupportedException
创建并返回此对象的一个副本。
副本的准确含义可能依赖于对象的类。
一般来说，对于任何对象x，如果表达式：
x.clone（）!
=x
是正确的，则表达式：
x.clone（）.getClass（）==x.getClass（）
将为true，但这些不是绝对条件。
一般情况下是：
x.clone（）.equals（x）
将为true，但这不是绝对条件。
按照惯例，返回的对象应该通过调用super.clone获得。
如果一个类及其所有的超类（Object除外）都遵守此约定，则x.clone（）.getClass（）==x.getClass（）。
按照惯例，此方法返回的对象应该独立于该对象（正被克隆的对象）。
要获得此独立性，在super.clone返回对象之前，有必要对该对象的一个或多个字段进行修改。
这通常意味着要复制包含正在被克隆对象的内部深层结构的所有可变对象，并使用对副本的引用替换对这些对象的引用。
如果一个类只包含基本字段或对不变对象的引用，那么通常不需要修改super.clone返回的对象中的字段。
Object类的clone方法执行特定的克隆操作。
首先，如果此对象的类不能实现接口Cloneable，则会抛出CloneNotSupportedException。
注意：
所有的数组都被视为实现接口Cloneable。
否则，此方法会创建此对象的类的一个新实例，并像通过分配那样，严格使用此对象相应字段的内容初始化该对象的所有字段；这些字段的内容没有被自我克隆。
所以，此方法执行的是该对象的浅表复制，而不深层复制操作。
Object类本身不实现接口Cloneable，所以在类为Object的对象上调用clone方法将会导致在运行时抛出异常。
返回：
此实例的一个克隆。
抛出：
CloneNotSupportedException–如果对象的类不支持Cloneable接口，则重写clone方法的子类也会抛出此异常，以指示无法克隆某个实例。
另请参见：
Cloneable
——————————————————————————–
toString
publicStringtoString（）
返回该对象的字符串表示。
通常，toString方法会返回一个以文本方式表示此对象的字符串。
结果应是一个简明但易于读懂。
建议所有子类都重写此方法。
Object类的toString方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at标记符@和此对象哈希码的无符号十六进制表示组成。
换句话说，该方法返回一个字符串，它的值等于：
getClass（）.getName（）+@+Integer.toHexString（hashCode（））
返回：
该对象的字符串表示形式。
——————————————————————————–
notify
publicfinalvoidnotify（）
唤醒在此对象监视器上等待的单个线程。
如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。
选择是任意性的，并在对实现做出决定时发生。
线程通过调用其中一个wait方法，在对象的监视器上等待。
直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。
被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。
此方法只应由作为此对象监视器的所有者的线程来调用。
通过以下三种方法之一，线程可以成为此对象监视器的所有者：
通过执行此对象的同步（Sychronized）实例方法。
通过执行在此对象上进行同步的synchronized语句的正文。
对于Class类型的对象，可以通过执行该类的同步静态方法。
一次只能有一个线程拥有对象的监视器。
抛出：
IllegalMonitorStateException–如果当前的线程不是此对象监视器的所有者。
另请参见：
notifyAll（）,wait（）
——————————————————————————–
notifyAll
publicfinalvoidnotifyAll（）
唤醒在此对象监视器上等待的所有线程。
线程通过调用其中一个wait方法，在对象的监视器上等待。
直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。
被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。
此方法只应由作为此对象监视器的所有者的线程来调用。
请参阅notify方法，了解线程能够成为监视器所有者的方法的描述。
抛出：
IllegalMonitorStateException–如果当前的线程不是此对象监视器的所有者。
另请参见：
notify（）,wait（）
——————————————————————————–
wait
publicfinalvoidwait（longtimeout）
throwsInterruptedException
导致当前的线程等待，直到其他线程调用此对象的notify（）方法或notifyAll（）方法，或者超过指定的时间量。
当前的线程必须拥有此对象监视器。
此方法导致当前线程（称之为T）将其自身放置在对象的等待集中，然后放弃此对象上的所有同步要求。
出于线程调度目的，线程T被禁用，且处于休眠状态，直到发生以下四种情况之一：
其他某个线程调用此对象的notify方法，并且线程T碰巧被任选为被唤醒的线程。
其他某个线程调用此对象的notifyAll方法。
其他某个线程中断线程T。
已经到达指定的实际时间。
但是，如果timeout为零，则不考虑实际时间，该线程将一直等待，直到获得通知。
然后，从对象的等待集中删除线程T，并重新进行线程调度。
然后，该线程以常规方式与其他线程竞争，以获得在该对象上同步的权利；一旦获得对该对象的控制权，该对象上的所有其同步声明都将被还原到以前的状态–这就是调用wait方法时的情况。
然后，线程T从wait方法的调用中返回。
所以，从wait方法返回时，该对象和线程T的同步状态与调用wait方法时的情况完全相同。
在没有被通知、中断或超时的情况下，线程还可以唤醒一个所谓的虚假唤醒（spuriouswakeup）。
虽然这种情况在实践中很少发生，但是应用程序必须通过以下方式防止其发生，即对应该导致该线程被提醒的条件进行测试，如果不满足该条件，则继续等待。
换句话说，等待应总是发生在循环中，如下面的示例：
synchronized（obj）{
while（）
obj.wait（timeout）;
…//Performactionappropriatetocondition
}
（有关这一主题的更多信息，请参阅DougLea撰写的《ConcurrentProgramminginJava（SecondEdition）》（Addison-Wesley,2000）中的第3.2.3节或JoshuaBloch撰写的《EffectiveJavaProgrammingLanguageGuide》（Addison-Wesley,2001）中的第50项。
如果当前线程在等待时被其他线程中断，则会抛出InterruptedException。
在按上述形式恢复此对象的锁定状态时才会抛出此异常。
注意，由于wait方法将当前的线程放入了对象的等待集中，所以它只能解除此对象的锁定；可以同步当前线程的任何其他对象在线程等待时仍处于锁定状态。
此方法只应由作为此对象监视器的所有者的线程来调用。
请参阅notify方法，了解线程能够成为监视器所有者的方法的描述。
参数：
timeout–要等待的最长时间（以毫秒为单位）。
抛出：
IllegalArgumentException–如果超时值为负。
IllegalMonitorStateException–如果当前的线程不是此对象监视器的所有者。
InterruptedException–如果在当前线程等待通知之前或者正在等待通知时，另一个线程中断了当前线程。
在抛出此异常时，当前线程的中断状态被清除。
另请参见：
notify（）,notifyAll（）
——————————————————————————–
wait
publicfinalvoidwait（longtimeout,
intnanos）
throwsInterruptedException
导致当前的线程等待，直到其他线程调用此对象的notify（）方法或notifyAll（）方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。
此方法类似于一个参数的wait方法，但它允许更好地控制在放弃之前等待通知的时间量。
用毫微秒度量的实际时间量可以通过以下公式计算出来：
1000000*timeout+nanos
在其他所有方面，此方法执行的操作与带有一个参数的wait（long）方法相同。
需要特别指出的是，wait（0,0）与wait（0）相同。
当前的线程必须拥有此对象监视器。
该线程发布对此监
升级会员 