A. java中Class<>和Class()有什么不同
Class<T>是java类型，即只要是Object类的子类都可以
class () 是确定的类型,即 class a(),则类型就为a
B. 什么是Java复合类
包含匿名内部类的，应该算是一种Synthetic的类
C. java文件是怎么执行的
首先：使用javac命令把.java文件编译成.class文件（字节码文件）
然后：JVM（java虚拟机）装载.class文件并翻译成机器码后运行java程序；
共同学习-----请参考：
我们手工执行java程序是这样的：
1 在记事本中或者是UE的文本编辑器中，写好源程序；
2 使用javac命令把源程序编译成.class文件；
编译后的.class（类字节码）文件中会包含以下内容：
ConstantPool：符号表；
FieldInfo：类中的成员变量信息；
MethodInfo：类中的方法描述；
Attribute：可选的附加节点。
FieldInfo节点包含成员变量的名称，诸如public,private,static等的标志。ConstantValue属性用来存储静态的不变的成员变量的值。Deprecated和Synthetic被用来标记一个成员变量是不被推荐的或由编译器生成的。
3 有了.class文件，我们执行 java 解释命令就可以运行java程序了。
现在我们主要讨论一下，当执行 java这个命令后，会发生什么事情呢？
首先，JVM装载.class，也就是类装载器装载类字节码。一个类装载器本身也是一个java类，所以，类装载器自身也需要被另外一个类装载器装载，这就出现了类似先有蛋，还是先有鸡的问题。但JAVA中的类装载器的这个问题却很容易解决。JAVA的虚拟机（JVM）中内嵌了一个称为Bootstrap类装载器，它是用特定于操作系统的本地代码实现的，属于JAVA虚拟机的内核，Bootstrap类不用专门的类装载器去进行装载。Bootstrap类负责加载JAVA核心包中的类（即rt.jar文件中的类），这些类的Class.getClassLoader()方法返回值为null，即表示是Bootstrap类装载器。JAVA核心包中有另外两个类装载器：ExtClassLoader和AppClassLoader，它们都是用JAVA语言编写的JAVA类，其中ExtClassLoader类装载负责加载存放在<JAVA_HOME>/jre/lib/ext目录下的jar包中的类，AppClassLoader负责加载应用程序的启动执行类，即当使用java命令去启动执行一个类时，JAVA虚拟机使用AppClassLoader加载这个类。在编译和运行JAVA程序时，都会通过ExtClassLoader类装载器去<JAVA_HOME>/jre/lib/ext目录下的JAR包中搜索要加载的类，所以，如果将包含例如Servlet API的jar包或者是javamail.jar包复制到该目录下，在编译Servlet或JavaMail程序时,就不必在CLASSPATH环境变量中增加包含Servlet API的jar包或者是javamail.jar包文件。
以上，就是一个JAVA程序执行的大致过程。
D. Java 枚举型为什么是静态的，以及是怎么实现的
是的，Java枚举型是静态常量，隐式地用static final修饰过。
确切地说，Java枚举型是“静态常量”，这里面包含了两层意思：
枚举型中的实例隐式地用static final修饰过。
枚举型作为某个类中的成员字段也隐式地用static final修饰过。
public class Traffic{
public enum Light{GREEN,YELLOW,RED}
}
还是你上面这个代码，反编译一下，你就能看到--编译器背着你偷偷做了哪些手脚：
/*
* Decompiled with CFR 0_118.
*/
package com.ciaoshen.thinkinjava.chapter19;
public class Traffic {
public static final class Light
extends Enum<Light> {
public static final /* enum */ Light GREEN = new Light();
public static final /* enum */ Light YELLOW = new Light();
public static final /* enum */ Light RED = new Light();
private static final /* synthetic */ Light[] $VALUES;
public static Light[] values() {
return (Light[])$VALUES.clone();
}
public static Light valueOf(String string) {
return Enum.valueOf(Light.class, string);
}
private Light() {
super(string, n);
}
static {
$VALUES = new Light[]{GREEN, YELLOW, RED};
}
}
}
首先，枚举型Light是个实实在在的类。继承自基类Enum<Light>。然后在你不知情的情况下，偷偷加了static final修饰词。
然后三个枚举实例GREEN, YELLOW, RED也确确实实是Light的实例。然而前面也加上了static final。
然后构造器也被偷偷地阉割成private。这种实例控制手段，是不是在单例器模式里也见过？所以枚举也是实现单例器的一种方法。
然后编译器还偷偷合成了Light[]数组，一个values( )方法，一个valueOf( )方法。这个values( )在Enum的文档里都找不到。
如果在Enum里定义一个相关方法，你还会看到一个匿名内部类：
public enum Light{
GREEN{public void show(){System.out.println("Green");}},
YELLOW{public void show(){System.out.println("Yellow");}},
RED{public void show(){System.out.println("Red");}};
}
反编译的结果如下：
/*
* Decompiled with CFR 0_118.
*/
package com.ciaoshen.thinkinjava.chapter18;
import java.io.PrintStream;
public class Light
extends Enum<Light> {
public static final /* enum */ Light GREEN = new Light("GREEN", 0){
public void show() {
System.out.println("Green");
}
};
public static final /* enum */ Light YELLOW = new Light("YELLOW", 1){
public void show() {
System.out.println("Yellow");
}
};
public static final /* enum */ Light RED = new Light("RED", 2){
public void show() {
System.out.println("Red");
}
};
private static final /* synthetic */ Light[] $VALUES;
public static Light[] values() {
return (Light[])$VALUES.clone();
}
public static Light valueOf(String string) {
return Enum.valueOf(Light.class, string);
}
private Light() {
super(string, n);
}
static {
$VALUES = new Light[]{GREEN, YELLOW, RED};
}
}
总之，Java的Enum枚举型整个就是一个大大的“语法糖”。明明是一个完整的类，但只向用户暴露几个静态常量，隐藏掉大部分实现的细节。
E. 有java混淆器的eclipse插件吗
android应用程序的混淆打包
1 . 在工程文件project.properties中加入下proguard.config=proguard.cfg ， 如下所示：
target=android-8
proguard.config=proguard.cfg
Eclipse会通过此配置在工程目录生成proguard.cfg文件
2 . 生成keystore (如已有可直接利用)
按照下面的命令行 在D:\Program Files\Java\jdk1.6.0_07\bin>目录下，输入keytool -genkey -alias android.keystore -keyalg RSA -validity 100000 -keystore android.keystore
参数意义：-validity主要是证书的有效期，写100000天；空格，退格键 都算密码。
命令执行后会在D:\Program Files\Java\jdk1.6.0_07\bin>目录下生成 android.keystore文件。
3. 在Eclipce的操作
File -> Export -> Export Android Application -> Select project -> Using the existing keystore , and input password -> select the destination APK file
经过混淆后的源代码，原先的类名和方法名会被类似a,b,c。。。的字符所替换，混淆的原理其实也就是类名和方法名的映射。
proguard 自己考一个就行
----------------------------------------------------------------------------------------
proguard 原理
Java代码编译成二进制class 文件，这个class
文件也可以反编译成源代码 ，除了注释外，原来的code 基本都可以看到。为了防止重要code
被泄露，我们往往需要混淆（Obfuscation code ， 也就是把方法，字段，包和类这些java
元素的名称改成无意义的名称，这样代码结构没有变化，还可以运行，但是想弄懂代码的架构却很难。 proguard
就是这样的混淆工具，它可以分析一组class 的结构，根据用户的配置，然后把这些class 文件的可以混淆java
元素名混淆掉。在分析class 的同时，他还有其他两个功能，删除无效代码（Shrinking 收缩），和代码进行优化
（Optimization Options）。
缺省情况下，proguard
会混淆所有代码，但是下面几种情况是不能改变java 元素的名称，否则就会这样就会导致程序出错。
一， 我们用到反射的地方。
二，
我们代码依赖于系统的接口，比如被系统代码调用的回调方法，这种情况最复杂。
三， 是我们的java
元素名称是在配置文件中配置好的。
所以使用proguard时，我们需要有个配置文件告诉proguard
那些java 元素是不能混淆的。
proguard 配置
最常用的配置选项
-dontwarn 缺省proguard
会检查每一个引用是否正确，但是第三方库里面往往有些不会用到的类，没有正确引用。如果不配置的话，系统就会报错。
-keep 指定的类和类成员被保留作为 入口
。
-keepclassmembers
指定的类成员被保留。
-keepclasseswithmembers
指定的类和类成员被保留，假如指定的类成员存在的话。
proguard 问题和风险
代码混淆后虽然有混淆优化的好处，但是它往往也会带来如下的几点问题
1，混淆错误，用到第三方库的时候，必须告诉 proguard
不要检查，否则proguard 会报错。
2，运行错误，当code
不能混淆的时候，我们必须要正确配置，否则程序会运行出错，这种情况问题最多。
3，调试苦难，出错了，错误堆栈是混淆后的代码
，自己也看不懂。
为了防止混淆出问题，你需要熟悉你所有的code ，系统的架构
，以及系统和你code的集成的接口，并细心分析。 同时你必须需要一轮全面的测试。 所以混淆也还是有一定风险的。
为了避免风险，你可以只是混淆部分关键的代码，但是这样你的混淆的效果也会有所降低。
常见的不能混淆的androidCode
Android 程序
，下面这样代码混淆的时候要注意保留。
Android系统组件，系统组件有固定的方法被系统调用。
被Android Resource
文件引用到的。名字已经固定，也不能混淆，比如自定义的View 。
Android Parcelable ，需要使用android
序列化的。
其他Anroid 官方建议
不混淆的，如
android.app.backup.BackupAgentHelper
android.preference.Preference
com.android.vending.licensing.ILicensingService
Java序列化方法，系统序列化需要固定的方法。
枚举 ，系统需要处理枚举的固定方法。
本地方法，不能修改本地方法名
annotations 注释
数据库驱动
有些resource 文件
用到反射的地方
如何实施
现在的系统已经配置为混淆时候会保留
Android系统组件
自定义View
Android Parcelable
Android R 文件
Android Parcelable
枚举
各个开发人员必须检查自己的code 是否用到反射
，和其他不能混淆的地方。告诉我来修改配置文件（已经保留的就不需要了）
目前系统部检查的第三方库为
-dontwarn
android.support.**
-dontwarn
com.tencent.**
-dontwarn
org.dom4j.**
-dontwarn
org.slf4j.**
-dontwarn
org.http.mutipart.**
-dontwarn
org.apache.**
-dontwarn
org.apache.log4j.**
-dontwarn
org.apache.commons.logging.**
-dontwarn
org.apache.commons.codec.binary.**
-dontwarn
weibo4android.**
proguard 参数
-include {filename}
从给定的文件中读取配置参数
-basedirectory {directoryname}
指定基础目录为以后相对的档案名称
-injars {class_path}
指定要处理的应用程序jar,war,ear和目录
-outjars {class_path}
指定处理完后要输出的jar,war,ear和目录的名称
-libraryjars {classpath}
指定要处理的应用程序jar,war,ear和目录所需要的程序库文件
-
指定不去忽略非公共的库类。
-
指定不去忽略包可见的库类的成员。
保留选项
-keep {Modifier} {class_specification}
保护指定的类文件和类的成员
-keepclassmembers {modifier}
{class_specification}
保护指定类的成员，如果此类受到保护他们会保护的更好
-keepclasseswithmembers
{class_specification}
保护指定的类和类的成员，但条件是所有指定的类和类成员是要存在。
-keepnames {class_specification}
保护指定的类和类的成员的名称（如果他们不会压缩步骤中删除）
-keepclassmembernames
{class_specification}
保护指定的类的成员的名称（如果他们不会压缩步骤中删除）
-keepclasseswithmembernames
{class_specification}
保护指定的类和类的成员的名称，如果所有指定的类成员出席（在压缩步骤之后）
-printseeds {filename}
列出类和类的成员-keep选项的清单，标准输出到给定的文件
压缩
-dontshrink
不压缩输入的类文件
-printusage
{filename}
-whyareyoukeeping {class_specification}
优化
-dontoptimize
不优化输入的类文件
-assumenosideeffects
{class_specification}
优化时假设指定的方法，没有任何副作用
-allowaccessmodification
优化时允许访问并修改有修饰符的类和类的成员
混淆
-dontobfuscate
不混淆输入的类文件
-printmapping
{filename}
-applymapping {filename}
重用映射增加混淆
-obfuscationdictionary {filename}
使用给定文件中的关键字作为要混淆方法的名称
-overloadaggressively
混淆时应用侵入式重载
-useuniqueclassmembernames
确定统一的混淆类的成员名称来增加混淆
-flattenpackagehierarchy {package_name}
重新包装所有重命名的包并放在给定的单一包中
-repackageclass {package_name}
重新包装所有重命名的类文件中放在给定的单一包中
-dontusemixedcaseclassnames
混淆时不会产生形形色色的类名
-keepattributes {attribute_name,...}
保护给定的可选属性，例如LineNumberTable,
LocalVariableTable, SourceFile, Deprecated, Synthetic, Signature,
and InnerClasses.
-renamesourcefileattribute {string}
设置源文件中给定的字符串常量
解决export打包的报错
这个时候export提示“conversion to Dalvik
format failed with error
1”错误，网上说法有好多种，最后我还是把proguard从4.4升级到4.8就解决了。
升级办法很简单，就是把android
sdk目录下的tool/proguard目录覆盖一下即可。
打包出来的程序如何调试
一旦打包出来，就不能用eclipse的logcat去看了，这里可以用android
sdk中ddms.bat的tool来看，一用就发现和logcat其实还是一个东西，就是多了个设备的选择。
使用 gson 需要的配置
当Gson用到了泛型就会有报错，这个真给郁闷了半天，提示“Missing
type
parameter”。最后找到一个资料给了一个解决办法，参考：http://stackoverflow.com/questio ...
sing-type-parameter。
另外我又用到了JsonObject，提交的Object里面的members居然被改成了a。所以上面给的东西还不够，还要加上
# 用到自己拼接的JsonObject
-keep class com.google.gson.JsonObject
{ *; }
个人建议减少这些依赖包混淆带来的麻烦，干脆都全部保留不混淆。例如
-keep class com.badlogic.** { *;
}
-keep class * implements
com.badlogic.gdx.utils.Json*
-keep class com.google.** { *;
}
使用libgdx需要的配置
验证打包效果
利用了apktool的反编译工具，把打包文件又解压了看了一下，如果包路径、类名、变量名、方法名这些变化和你期望一致，那就OK了。命令：
apktool.bat d xxx.apk
destdir
配置实例
-injars
androidtest.jar【jar包所在地址】
-outjars
out【输出地址】
-libraryjars
'D:\android-sdk-windows\platforms\android-9\android.jar'
【引用的库的jar，用于解析injars所指定的jar类】
-optimizationpasses
5
-dontusemixedcaseclassnames
【混淆时不会产生形形色色的类名 】
-
【指定不去忽略非公共的库类。 】
-dontpreverify
【不预校验】
-verbose
-optimizations
!code/simplification/arithmetic,!field/*,!class/merging/*
【优化】
-keep public class * extends
android.app.Activity【不进行混淆保持原样】
-keep public class * extends
android.app.Application
-keep public class * extends
android.app.Service
-keep public class * extends
android.content.BroadcastReceiver
-keep public class * extends
android.content.ContentProvider
-keep public class * extends
android.app.backup.BackupAgentHelper
-keep public class * extends
android.preference.Preference
-keep public class
com.android.vending.licensing.ILicensingService
-keep public abstract interface
com.asqw.android.Listener{
public protected ;
【所有方法不进行混淆】
}
-keep public class
com.asqw.android{
public void Start(java.lang.String);
【对该方法不进行混淆】
}
-keepclasseswithmembernames class * {
【保护指定的类和类的成员的名称，如果所有指定的类成员出席（在压缩步骤之后）】
native ;
}
-keepclasseswithmembers class * {
【保护指定的类和类的成员，但条件是所有指定的类和类成员是要存在。】
public (android.content.Context,
android.util.AttributeSet);
}
-keepclasseswithmembers class *
{
public (android.content.Context,
android.util.AttributeSet, int);
}
-keepclassmembers class * extends
android.app.Activity {【保护指定类的成员，如果此类受到保护他们会保护的更好
】
public void
*(android.view.View);
}
-keepclassmembers enum *
{
public static **[]
values();
public static **
valueOf(java.lang.String);
}
-keep class * implements
android.os.Parcelable {【保护指定的类文件和类的成员】
public static final
android.os.Parcelable$Creator *;
}
//不混淆指定包下的类
-keep class
com.aspire.**
F. Java 什么是注解及注解原理详细介绍
1、注解是针对Java编译器的说明。
可以给Java包、类型(类、接口、枚举)、构造器、方法、域、参数和局部变量进行注解。Java编译器可以根据指令来解释注解和放弃注解，或者将注解放到编译后的生成的class文件中，运行时可用。
2、注解和注解类型
注解类型是一种特殊的接口类型，注解是注解注解类型的一个实例。
注解类型也有名称和成员，注解中包含的信息采用键值对形式，可以有0个或多个。
3、Java中定义的一些注解：
@Override 告诉编译器这个方法要覆盖一个超类方法，防止程序员覆盖出错。
@Deprecated 这个标识方法或类(接口等类型)过期，警告用户不建议使用。
@SafeVarargs JDK7新增，避免可变参数在使用泛型化时候警告”执行时期无法具体确认参数类型“，当然，也可以用@SuppressWarnings来避免检查，显然后者的抑制的范围更大。
@SuppressWarnings(value={"unchecked"}) 抑制编译警告，应用于类型、构造器、方法、域、参数以及局部变量。 value是类型数组，有效取值为：
all, to suppress all warnings
boxing, to suppress warnings relative to boxing/unboxing operations
cast, to suppress warnings relative to cast operations
dep-ann, to suppress warnings relative to deprecated annotation
deprecation, to suppress warnings relative to deprecation
fallthrough, to suppress warnings relative to missing breaks in switch statements
finally, to suppress warnings relative to finally block that don't return
hiding, to suppress warnings relative to locals that hide variable
incomplete-switch, to suppress warnings relative to missing entries in a switch statement (enum case)
javadoc, to suppress warnings relative to javadoc warnings
nls, to suppress warnings relative to non-nls string literals
null, to suppress warnings relative to null analysis
rawtypes, to suppress warnings relative to usage of raw types
restriction, to suppress warnings relative to usage of discouraged or forbidden references
serial, to suppress warnings relative to missing serialVersionUID field for a serializable class
static-access, to suppress warnings relative to incorrect static access
static-method, to suppress warnings relative to methods that could be declared as static
super, to suppress warnings relative to overriding a method without super invocations
synthetic-access, to suppress warnings relative to unoptimized access from inner classes
unchecked, to suppress warnings relative to unchecked operations
unqualified-field-access, to suppress warnings relative to field access unqualified
unused, to suppress warnings relative to unused code and dead code
4、注解的定义
使用 @interface 关键字声明一个注解
public @interface MyAnnotation1
注解中可以定义属性
String name default “defval”;
value是注解中的特殊属性
注解中定义的属性如果名称为 value， 此属性在使用时可以省写属性名
例如，声明一个注解：
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnno1 {
String msg();
int value();
}
G. 深入理解Java中为什么内部类可以访问外部类的成员
内部类简介
虽然Java是一门相对比较简单的编程语言，但是对于初学者， 还是有很多东西感觉云里雾里，
理解的不是很清晰。内部类就是一个经常让初学者感到迷惑的特性。 即使现在我自认为Java学的不错了，
但是依然不是很清楚。其中一个疑惑就是为什么内部类对象可以访问外部类对象中的成员（包括成员变量和成员方法）？
早就想对内部类这个特性一探究竟了，今天终于抽出时间把它研究了一下。
内部类就是定义在一个类内部的类。定义在类内部的类有两种情况：一种是被static关键字修饰的， 叫做静态内部类，
另一种是不被static关键字修饰的， 就是普通内部类。 在下文中所提到的内部类都是指这种不被static关键字修饰的普通内部类。
静态内部类虽然也定义在外部类的里面， 但是它只是在形式上（写法上）和外部类有关系，
其实在逻辑上和外部类并没有直接的关系。而一般的内部类，不仅在形式上和外部类有关系（写在外部类的里面）， 在逻辑上也和外部类有联系。
这种逻辑上的关系可以总结为以下两点：
1 内部类对象的创建依赖于外部类对象；
2 内部类对象持有指向外部类对象的引用。
上边的第二条可以解释为什么在内部类中可以访问外部类的成员。就是因为内部类对象持有外部类对象的引用。但是我们不禁要问， 为什么会持有这个引用？ 接着向下看， 答案在后面。
通过反编译字节码获得答案
在源代码层面， 我们无法看到原因，因为Java为了语法的简介， 省略了很多该写的东西， 也就是说很多东西本来应该在源代码中写出， 但是为了简介起见， 不必在源码中写出，编译器在编译时会加上一些代码。 现在我们就看看Java的编译器为我们加上了什么？
首先建一个工程TestInnerClass用于测试。 在该工程中为了简单起见， 没有创建包， 所以源代码直接在默认包中。在该工程中， 只有下面一个简单的文件。
?
1
2
3
4
5
6
7
8
9
public class Outer {
int outerField = 0;
class Inner{
void InnerMethod(){
int i = outerField;
}
}
}
该文件很简单， 就不用过多介绍了。 在外部类Outer中定义了内部类Inner， 并且在Inner的方法中访问了Outer的成员变量outerField。
虽然这两个类写在同一个文件中， 但是编译完成后， 还是生成各自的class文件：
这里我们的目的是探究内部类的行为， 所以只反编译内部类的class文件Outer$Inner.class 。 在命令行中， 切换到工程的bin目录， 输入以下命令反编译这个类文件：
?
1
javap -classpath . -v Outer$Inner
-classpath . 说明在当前目录下寻找要反编译的class文件
-v 加上这个参数输出的信息比较全面。包括常量池和方法内的局部变量表， 行号， 访问标志等等。
注意， 如果有包名的话， 要写class文件的全限定名， 如：
?
1
javap -classpath . -v com..Outer$Inner
反编译的输出结果很多， 为了篇幅考虑， 在这里我们省略了常量池。 下面给出除了常量池之外的输出信息。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
{
final Outer this$0;
flags: ACC_FINAL, ACC_SYNTHETIC
Outer$Inner(Outer);
flags:
Code:
stack=2, locals=2, args_size=2
0: aload_0
1: aload_1
2: putfield #10 // Field this$0:LOuter;
5: aload_0
6: invokespecial #12 // Method java/lang/Object."<init>":()V
9: return
LineNumberTable:
line 5: 0
LocalVariableTable:
Start Length Slot Name Signature
0 10 0 this LOuter$Inner;
void InnerMethod();
flags:
Code:
stack=1, locals=2, args_size=1
0: aload_0
1: getfield #10 // Field this$0:LOuter;
4: getfield #20 // Field Outer.outerField:I
7: istore_1
8: return
LineNumberTable:
line 7: 0
line 8: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 this LOuter$Inner;
8 1 1 i I
}</init>
首先我们会看到， 第一行的信息如下：
?
1
final Outer this$0;
这句话的意思是， 在内部类Outer$Inner中， 存在一个名字为this$0 ， 类型为Outer的成员变量， 并且这个变量是final的。
其实这个就是所谓的“在内部类对象中存在的指向外部类对象的引用”。但是我们在定义这个内部类的时候， 并没有声明它，
所以这个成员变量是编译器加上的。
虽然编译器在创建内部类时为它加上了一个指向外部类的引用， 但是这个引用是怎样赋值的呢？毕竟必须先给他赋值，它才能指向外部类对象。下面我们把注意力转移到构造函数上。 下面这段输出是关于构造函数的信息。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Outer$Inner(Outer);
flags:
Code:
stack=2, locals=2, args_size=2
0: aload_0
1: aload_1
2: putfield #10 // Field this$0:LOuter;
5: aload_0
6: invokespecial #12 // Method java/lang/Object."<init>":()V
9: return
LineNumberTable:
line 5: 0
LocalVariableTable:
Start Length Slot Name Signature
0 10 0 this LOuter$Inner;</init>
我们知道， 如果在一个类中， 不声明构造方法的话， 编译器会默认添加一个无参数的构造方法。 但是这句话在这里就行不通了， 因为我们明明看到， 这个构造函数有一个构造方法， 并且类型为Outer。 所以说，
编译器会为内部类的构造方法添加一个参数， 参数的类型就是外部类的类型。
下面我们看看在构造参数中如何使用这个默认添加的参数。 我们来分析一下构造方法的字节码。 下面是每行字节码的意义：
aload_0 ：
将局部变量表中的第一个引用变量加载到操作数栈。 这里有几点需要说明。
局部变量表中的变量在方法执行前就已经初始化完成；局部变量表中的变量包括方法的参数；成员方法的局部变量表中的第一个变量永远是this；操作数栈就是
执行当前代码的栈。所以这句话的意思是： 将this引用从局部变量表加载到操作数栈。
aload_1：
将局部变量表中的第二个引用变量加载到操作数栈。 这里加载的变量就是构造方法中的Outer类型的参数。
putfield #10 // Field this$0:LOuter;
使用操作数栈顶端的引用变量为指定的成员变量赋值。 这里的意思是将外面传入的Outer类型的参数赋给成员变量this$0 。
这一句putfield字节码就揭示了， 指向外部类对象的这个引用变量是如何赋值的。
下面几句字节码和本文讨论的话题无关， 只做简单的介绍。 下面几句字节码的含义是： 使用this引用调用父类（Object）的构造方法然后返回。
用我们比较熟悉的形式翻译过来， 这个内部类和它的构造函数有点像这样： （注意， 这里不符合Java的语法， 只是为了说明问题）
?
1
2
3
4
5
6
7
8
class Outer$Inner{
final Outer this$0;
public Outer$Inner(Outer outer){
this.this$0 = outer;
super();
}
}
说到这里， 可以推想到， 在调用内部类的构造器初始化内部类对象的时候， 编译器默认也传入外部类的引用。 调用形式有点像这样： （注意， 这里不符合java的语法， 只是为了说明问题）
vcq9ysfP4M2stcShoyDU2sTasr//wOC1xLPJ1LGx5MG/b3V0ZXJGaWVsZKOsIM/Cw++NDQtcSjugo8YnI+Cgo8cHJlIGNsYXNzPQ=="brush:java;">
void InnerMethod();
flags:
Code:
stack=1, locals=2, args_size=1
0: aload_0
1: getfield #10 // Field this$0:LOuter;
4: getfield #20 // Field
Outer.outerField:I
7: istore_1
8: return
getfield #10 // Field this$0:LOuter;
将成员变量this$0加载到操作数栈上来
getfield #20 // Field Outer.outerField:I
使用上面加载的this$0引用， 将外部类的成员变量outerField加载到操作数栈
istore_1
将操作数栈顶端的int类型的值保存到局部变量表中的第二个变量上（注意， 第一个局部变量被this占用，
第二个局部变量是i）。操作数栈顶端的int型变量就是上一步加载的outerField变量。 所以， 这句字节码的含义就是：
使用outerField为i赋值。
上面三步就是内部类中是如何通过指向外部类对象的引用， 来访问外部类成员的。
文章写到这里， 相信读者对整个原理就会有一个清晰的认识了。 下面做一下总结：
本文通过反编译内部类的字节码， 说明了内部类是如何访问外部类对象的成员的，除此之外， 我们也对编译器的行为有了一些了解， 编译器在编译时会自动加上一些逻辑， 这正是我们感觉困惑的原因。
关于内部类如何访问外部类的成员， 分析之后其实也很简单， 主要是通过以下几步做到的：
1 编译器自动为内部类添加一个成员变量， 这个成员变量的类型和外部类的类型相同， 这个成员变量就是指向外部类对象的引用；
2 编译器自动为内部类的构造方法添加一个参数， 参数的类型是外部类的类型， 在构造方法内部使用这个参数为1中添加的成员变量赋值；
3 在调用内部类的构造函数初始化内部类对象时， 会默认传入外部类的引用。
H. java，求高手讲解一下一个枚举的例子
结果：Mr. John Doe
转的。枚举是一个特殊的类。
枚举类型是JDK5.0的新特征 。Sun引进了一个全新的关键字enum来定义一个枚举类 。下面就是一个典型枚举类型的定义：
Java代码：
public enum Color{
RED，BLUE，BLACK，YELLOW，GREEN
}
显然，enum很像特殊的class，实际上enum声明定义的类型就是一个类 。 而这些类都是类库中Enum类的子类（java.lang.Enum） 。它们继承了这个Enum中的许多有用的方法 。我们对代码编译之后发现，编译器将enum类型单独编译成了一个字节码文件：Color.class 。
Color字节码代码
final enum hr.test.Color {
// 所有的枚举值都是类静态常量
public static final enum hr.test.Color RED;
public static final enum hr.test.Color BLUE;
public static final enum hr.test.Color BLACK;
public static final enum hr.test.Color YELLOW;
public static final enum hr.test.Color GREEN;
private static final synthetic hr.test.Color〔〕 ENUM$VALUES;
// 初始化过程，对枚举类的所有枚举值对象进行第一次初始化
static {
0 new hr.test.Color 〔1〕
3 p
4 ldc 〔16〕 //把枚举值字符串“RED”压入操作数栈
6 iconst_0 // 把整型值0压入操作数栈
7 invokespecial hr.test.Color（java.lang.String， int） 〔17〕 //调用Color类的私有构造器创建Color对象RED
10 putstatic hr.test.Color.RED ： hr.test.Color 〔21〕 //将枚举对象赋给Color的静态常量RED 。
。.. 。.. 。.. 枚举对象BLUE等与上同
102 return
};
// 私有构造器，外部不可能动态创建一个枚举类对象（也就是不可能动态创建一个枚举值） 。
private Color（java.lang.String arg0， int arg1）{
// 调用父类Enum的受保护构造器创建一个枚举对象
3 invokespecial java.lang.Enum（java.lang.String， int） 〔38〕
};
public static hr.test.Color〔〕 values（）;
// 实现Enum类的抽象方法
public static hr.test.Color valueOf（java.lang.String arg0）;
}
下面我们就详细介绍enum定义的枚举类的特征及其用法 。（后面均用Color举例）
1、Color枚举类就是class，而且是一个不可以被继承的final类 。
其枚举值（RED，BLUE. 。.）都是Color类型的类静态常量， 我们可以通过下面的方式来得到Color枚举类的一个实例：
Color c=Color.RED;
注意：这些枚举值都是public static final的，也就是我们经常所定义的常量方式，因此枚举类中的枚举值最好全部大写 。
2、即然枚举类是class，当然在枚举类型中有构造器，方法和数据域 。
但是，枚举类的构造器有很大的不同：
（1） 构造器只是在构造枚举值的时候被调用 。
Java代码：
enum Color{
RED（255，0，0），BLUE（0，0，255），BLACK（0，0，0），YELLOW（255，255，0），GREEN（0，255，0）;
//构造枚举值，比如RED（255，0，0）
private Color（int rv，int gv，int bv）{
this.redValue=rv;
this.greenValue=gv;
this.blueValue=bv;
}
public String toString（）{ //覆盖了父类Enum的toString（）
return super.toString（）+“（”+redValue+“，”+greenValue+“，”+blueValue+“）”;
}
private int redValue; //自定义数据域，private为了封装 。
private int greenValue;
private int blueValue;
}
（2） 构造器只能私有private，绝对不允许有public构造器 。 这样可以保证外部代码无法新构造枚举类的实例 。这也是完全符合情理的，因为我们知道枚举值是public static final的常量而已 。 但枚举类的方法和数据域可以允许外部访问 。
Java代码：
public static void main（String args〔〕）
{
// Color colors=new Color（100，200，300）; //wrong
Color color=Color.RED;
System.out.println（color）; // 调用了toString（）方法
}
3、所有枚举类都继承了Enum的方法，下面我们详细介绍这些方法 。
（1） ordinal（）方法： 返回枚举值在枚举类种的顺序 。这个顺序根据枚举值声明的顺序而定 。
Color.RED.ordinal（）; //返回结果：0
Color.BLUE.ordinal（）; //返回结果：1
（2） compareTo（）方法： Enum实现了java.lang.Comparable接口，因此可以比较象与指定对象的顺序 。Enum中的compareTo返回的是两个枚举值的顺序之差 。当然，前提是两个枚举值必须属于同一个枚举类，否则会抛出ClassCastException（）异常 。（具体可见源代码）
Color.RED.compareTo（Color.BLUE）; //返回结果 -1
（3） values（）方法： 静态方法，返回一个包含全部枚举值的数组 。
Color〔〕 colors=Color.values（）;
for（Color c:colors）{
System.out.print（c+“，”）;
}//返回结果：RED，BLUE，BLACK YELLOW，GREEN，
（4） toString（）方法： 返回枚举常量的名称 。
Color c=Color.RED;
System.out.println（c）;//返回结果： RED
（5） valueOf（）方法： 这个方法和toString方法是相对应的，返回带指定名称的指定枚举类型的枚举常量 。
Color.valueOf（“BLUE”）; //返回结果： Color.BLUE
（6） equals（）方法： 比较两个枚举类对象的引用 。
Java代码：
//JDK源代码：
public final boolean equals（Object other） {
return this==other;
}
4、枚举类可以在switch语句中使用 。
Java代码：
Color color=Color.RED;
switch（color）{
case RED： System.out.println（“it‘s red”）;break;
case BLUE： System.out.println（“it’s blue”）;break;
case BLACK： System.out.println（“it‘s blue”）;break;
}
I. java中什么是bridge method
Java中的bridge method又叫桥接方法
桥接方法是 JDK 1.5 引入泛型后，为了使Java的泛型方法生成的字节码和 1.5 版本前的字节码相兼容，由编译器自动生成的方法。
我们可以通过Method.isBridge()方法来判断一个方法是否是桥接方法，在字节码中桥接方法会被标记为ACC_BRIDGE和ACC_SYNTHETIC，其中ACC_BRIDGE用于说明这个方法是由编译生成的桥接方法，ACC_SYNTHETIC说明这个方法是由编译器生成，并且不会在源代码中出现。