Java编程思想重点笔记Java开发必看Word文件下载.docx
《Java编程思想重点笔记Java开发必看Word文件下载.docx》由会员分享，可在线阅读，更多相关《Java编程思想重点笔记Java开发必看Word文件下载.docx（30页珍藏版）》请在冰点文库上搜索。
∙在父类构造函数内部调用具有多态行为的函数将导致无法预测的结果，因为此时子类对象还没初始化，此时调用子类方法不会得到我们想要的结果。
∙classGlyph{
∙voiddraw（）{
∙System.out.println（"
Glyph.draw（）"
）;
∙Glyph（）{
Glyph（）beforedraw（）"
∙draw（）;
Glyph（）afterdraw（）"
∙classRoundGlyphextendsGlyph{
∙privateintradius=1;
∙RoundGlyph（intr）{
∙radius=r;
RoundGlyph.RoundGlyph（）.radius="
+radius）;
RoundGlyph.draw（）.radius="
∙publicclassPolyConstructors{
∙newRoundGlyph（5）;
Glyph（）beforedraw（）
RoundGlyph.draw（）.radius=0
Glyph（）afterdraw（）
RoundGlyph.RoundGlyph（）.radius=5
为什么会这样输出？
这就要明确掌握Java中构造函数的调用顺序：
（1）在其他任何事物发生之前，将分配给对象的存储空间初始化成二进制0；
（2）调用基类构造函数。
从根开始递归下去，因为多态性此时调用子类覆盖后的draw（）方法（要在调用RoundGlyph构造函数之前调用），由于步骤1的缘故，我们此时会发现radius的值为0；
（3）按声明顺序调用成员的初始化方法；
（4）最后调用子类的构造函数。
∙只有非private方法才可以被覆盖，但是还需要密切注意覆盖private方法的现象，这时虽然编译器不会报错，但是也不会按照我们所期望的来执行，即覆盖private方法对子类来说是一个新的方法而非重载方法。
因此，在子类中，新方法名最好不要与基类的private方法采取同一名字（虽然没关系，但容易误解，以为能够覆盖基类的private方法）。
∙Java类中属性域的访问操作都由编译器解析，因此不是多态的。
父类和子类的同名属性都会分配不同的存储空间，如下：
∙//Directfieldaccessisdeterminedatcompiletime.
∙classSuper{
∙publicintfield=0;
∙publicintgetField（）{
∙returnfield;
∙classSubextendsSuper{
∙publicintfield=1;
∙publicintgetSuperField（）{
∙returnsuper.field;
∙publicclassFieldAccess{
∙Supersup=newSub（）;
sup.filed="
+sup.field+
∙"
sup.getField（）="
+sup.getField（））;
∙Subsub=newSub（）;
sub.filed="
+sub.field+
sub.getField（）="
+sub.getField（）+
sub.getSuperField（）="
+sub.getSuperField（））;
sup.filed=0,sup.getField（）=1
sub.filed=1,sub.getField（）=1,sub.getSuperField（）=0
Sub子类实际上包含了两个称为field的域，然而在引用Sub中的field时所产生的默认域并非Super版本的field域，因此为了得到Super.field，必须显式地指明super.field。
2.is-a关系和is-like-a关系
∙is-a关系属于纯继承，即只有在基类中已经建立的方法才可以在子类中被覆盖，如下图所示：
基类和子类有着完全相同的接口，这样向上转型时永远不需要知道正在处理的对象的确切类型，这通过多态来实现。
∙is-like-a关系：
子类扩展了基类接口。
它有着相同的基本接口，但是他还具有由额外方法实现的其他特性。
缺点就是子类中接口的扩展部分不能被基类访问，因此一旦向上转型，就不能调用那些新方法。
3.运行时类型信息（RTTI+反射）
∙概念
RTTI：
运行时类型信息使得你可以在程序运行时发现和使用类型信息。
∙使用方式
Java是如何让我们在运行时识别对象和类的信息的，主要有两种方式（还有辅助的第三种方式，见下描述）：
∙一种是“传统的”RTTI，它假定我们在编译时已经知道了所有的类型，比如Shapes=（Shape）s1；
∙另一种是“反射”机制，它运行我们在运行时发现和使用类的信息，即使用Class.forName（）。
∙其实还有第三种形式，就是关键字instanceof，它返回一个bool值，它保持了类型的概念，它指的是“你是这个类吗？
或者你是这个类的派生类吗？
”。
而如果用==或equals比较实际的Class对象，就没有考虑继承—它或者是这个确切的类型，或者不是。
∙工作原理
要理解RTTI在Java中的工作原理，首先必须知道类型信息在运行时是如何表示的，这项工作是由称为Class对象的特殊对象完成的，它包含了与类有关的信息。
Java送Class对象来执行其RTTI，使用类加载器的子系统实现。
无论何时，只要你想在运行时使用类型信息，就必须首先获得对恰当的Class对象的引用，获取方式有三种：
（1）如果你没有持有该类型的对象，则Class.forName（）就是实现此功能的便捷途，因为它不需要对象信息；
（2）如果你已经拥有了一个感兴趣的类型的对象，那就可以通过调用getClass（）方法来获取Class引用了，它将返回表示该对象的实际类型的Class引用。
Class包含很有有用的方法，比如：
packagertti;
interfaceHasBatteries{}
interfaceWaterProof{}
interfaceShoots{}
classToy{
Toy（）{}
Toy（inti）{}
}
classFancyToyextendsToy
implementsHasBatteries,WaterProof,Shoots{
FancyToy（）{
super
（1）;
}
publicclassRTTITest{
staticvoidprintInfo（Classcc）{
System.out.println（"
Classname:
"
+cc.getName（）+
isinterface?
["
+cc.isInterface（）+"
]"
Simplename:
+cc.getSimpleName（））;
Canonicalname:
+cc.getCanonicalName（））;
publicstaticvoidmain（String[]args）{
Classc=null;
try{
c=Class.forName（"
rtti.FancyToy"
//必须是全限定名（包名+类名）
}catch（ClassNotFoundExceptione）{
Can'
tfindFancyToy"
System.exit
（1）;
printInfo（c）;
for（Classface:
c.getInterfaces（））{
printInfo（face）;
Classup=c.getSuperclass（）;
Objectobj=null;
//Requiresdefaultconstructor.
obj=up.newInstance（）;
}catch（InstantiationExceptione）{
tInstantiate"
}catch（IllegalAccessExceptione）{
taccess"
printInfo（obj.getClass（））;
rtti.FancyToy,isinterface?
[false]
FancyToy
rtti.FancyToy
rtti.HasBatteries,isinterface?
[true]
HasBatteries
rtti.HasBatteries
rtti.WaterProof,isinterface?
WaterProof
rtti.WaterProof
rtti.Shoots,isinterface?
Shoots
rtti.Shoots
rtti.Toy,isinterface?
Toy
rtti.Toy
（3）Java还提供了另一种方法来生成对Class对象的引用，即使用类字面常量。
比如上面的就像这样：
FancyToy.class;
来引用。
这样做不仅更简单，而且更安全，因为它在编译时就会受到检查（因此不需要置于try语句块中），并且它根除了对forName方法的引用，所以也更高效。
类字面常量不仅可以应用于普通的类，也可以应用于接口、数组以及基本数据类型。
注意：
当使用“.class”来创建对Class对象的引用时，不会自动地初始化该Class对象，初始化被延迟到了对静态方法（构造器隐式的是静态的）或者非final静态域（注意final静态域不会触发初始化操作）进行首次引用时才执行：
。
而使用Class.forName时会自动的初始化。
为了使用类而做的准备工作实际包含三个步骤：
-加载：
由类加载器执行。
查找字节码，并从这些字节码中创建一个Class对象
-链接：
验证类中的字节码，为静态域分配存储空间，并且如果必需的话，将解析这个类创建的对其他类的所有引用。
-初始化：
如果该类具有超类，则对其初始化，执行静态初始化器和静态初始化块。
这一点非常重要，下面通过一个实例来说明这两者的区别：
importjava.util.Random;
classInitable{
staticfinalintstaticFinal=47;
staticfinalintstaticFinal2=ClassInitialization.rand.nextInt（1000）;
static{
InitializingInitable"
classInitable2{
staticintstaticNonFinal=147;
InitializingInitable2"
classInitable3{
staticintstaticNonFinal=74;
InitializingInitable3"
publicclassClassInitialization{
publicstaticRandomrand=newRandom（47）;
//Doesnottriggerinitialization
Classinitable=Initable.class;
AftercreatingInitableref"
System.out.println（Initable.staticFinal）;
//Doestriggerinitialization（rand（）isstaticmethod）
System.out.println（Initable.staticFinal2）;
//Doestriggerinitialization（notfinal）
System.out.println（Initable2.staticNonFinal）;
Classinitable3=Class.forName（"
rtti.Initable3"
}catch（ClassNotFoundExceptione）{
tfindInitable3"
AftercreatingInitable3ref"
System.out.println（Initable3.staticNonFinal）;
AftercreatingInitableref
47
InitializingInitable
258
InitializingInitable2
147
InitializingInitable3
AftercreatingInitable3ref
74
∙RTTI的限制？
如何突破？
—反射机制
如果不知道某个对象的确切类型，RTTI可以告诉你，但是有一个限制：
这个类型在编译时必须已知，这样才能使用RTTI识别它，也就是在编译时，编译器必须知道所有要通过RTTI来处理的类。
可以突破这个限制吗？
是的，突破它的就是反射机制。
Class类与java.lang.reflect类库一起对反射的概念进行了支持，该类库包含了Field、Method以及Constructor类（每个类都实现了Member接口）。
这些类型的对象是由JVM在运行时创建的，用以表示未知类里对应的成员。
这样你就可以使用Constructor创建新的对象，用get（）/set（）方法读取和修改与Field对象关联的字段，用invoke（）方法调用与Method对象关联的方法。
另外，还可以调用getFields（）、getMethods（）和getConstructors（）等很便利的方法，以返回表示字段、方法以及构造器的对象的数组。
这样，匿名对象的类信息就能在运行时被完全确定下来，而在编译时不需要知道任何事情。
####反射与RTTI的区别
当通过反射与一个未知类型的对象打交道时，JVM只是简单地检查这个对象，看它属于哪个特定的类（就像RTTI那样），在用它做其他事情之前必须先加载那个类的Class对象，因此，那个类的.class文件对于JVM来说必须是可获取的：
要么在本地机器上，要么可以通过网络取得。
所以RTTI与反射之间真正的区别只在于：
对RTTI来说，编译器在编译时打开和检查.class文件（也就是可以用普通方法调用对象的所有方法）；
而对于反射机制来说，.class文件在编译时是不可获取的，所以是在运行时打开和检查.class文件。
下面的例子是用反射机制打印出一个类的所有方法（包括在基类中定义的方法）：
packagetypeinfo;
importjava.lang.reflect.Constructor;
importjava.lang.reflect.Method;
importjava.util.regex.Pattern;
//Usingreflectiontoshowallthemethodsofaclass.
//evenifthemethodsaredefinedinthebaseclass.
publicclassShowMethods{
privatestaticStringusage=
usage:
\n"
+
ShowMethodsqualified.class.name\n"
+
Toshowallmethodsinclassor:
ShowMethodsqualified.class.nameword\n"
Tosearchformethodsinvolving'
word'
"
privatestaticPatternp=Ppile（"
\\w+\\."
if（args.length<
1）{
System.out.println（usage）;
System.exit（0）;
intlines=0;
Class<
?
>
c=Class.forName（args[0]）;
Method[]methods=c.getMethods（）;
Constructor[]ctors=c.getConstructors（）;
if（args.length==1）{
for（Methodmethod:
methods）{
System.out.println（p.matcher（method.toString（））.replaceAll（"
））;
for（Constructorctor:
ctors）{
System.out.println（p.matcher（ctor.toString（））.replaceAll（"
lines=methods.length+ctors.length;
}else{
if（method.toString（）.indexOf（args[1]）!
=-1）{
lines++;
if（ctor.toString（）.indexOf（args[1]）!
l
升级会员 