本笔记参考自： 《On Java 中文版》
接口和类型信息
interface关键字的一个重要目标就是允许程序员隔离组件，减少耦合。但我们可以通过类型信息来绕过接口的隔离，这使得接口不一定能够保证解耦。
为了演示这一实现，我们需要先创建一个接口：
package reflection.interfacea;
public interface A {
void f();
}接下来的例子展示了如何绕过接口，偷偷访问实际的实现类型：
package reflection;
import reflection.interfacea.A;
class B implements A {
@Override
public void f() {
}
public void g() {
}
}
public class InterfaceViolation {
public static void main(String[] args) {
A a = new B();
a.f();
// a.g(); // 此时还不能访问方法g()
System.out.println(a.getClass().getName());
if (a instanceof B) {
B b = (B) a;
b.g();
}
}
}通过反射，我们将a强制转换成了B类，以此来调用A中不存在的方法。
很显然，这种实现是合理的。但当一些客户程序员使用这些代码时，他们也可能会通过这种方式的调用，使得其代码与我们的代码之间的耦合程度超出我们的预期。换言之，instanceof并不能够保护我们的代码。
Windows系统就存在类似的问题……
这时有两种解决方案：①直接声明，让客户程序员自己承当使用额外代码带来的后果。②而另一种方法，就是对代码的访问权限加以控制：
【例子：通过包访问权限隔绝包外的访问】
package reflection.packageaccess;
import reflection.interfacea.A;
class C implements A {
@Override
public void f() {
System.out.println("public C.f()");
}
public void g() {
System.out.println("public C.g()");
}
void u() {
System.out.println("package C.u()");
}
protected void v() {
System.out.println("protected C.v()");
}
private void w() {
System.out.println("private C.w()");
}
}
public class HiddenC {
public static A makeA() {
return new C();
}
}我们创建了一个接口A的实现：C类，并将其放到一个单独的包中。代码中只有HiddenC类存在一个与外界通信的接口makeA()。
遗憾的是，我们依旧有办法绕过包的隐藏：
【例子：绕过包隐藏】
package reflection;
import reflection.packageaccess.HiddenC;
import reflection.interfacea.A;
import java.lang.reflect.Method;
public class HiddenImplementation {
public static void main(String[] args)
throws Exception {
A a = HiddenC.makeA();
a.f();
// 通过反射可以得到隐藏的类名
System.out.println(a.getClass().getName());
// 编译错误，无法找到"C"：
/* if (a instanceof C) {
C c = (C) a;
c.g();
} */
// 但依旧可以通过反射调用被隐藏起来的方法：
callHiddenMethod(a, "g");
// 以及访问权限更小的方法：
callHiddenMethod(a, "u");
callHiddenMethod(a, "v");
callHiddenMethod(a, "w");
}
static void callHiddenMethod(
Object a, String methodName)
throws Exception {
Method g =
a.getClass().getDeclaredMethod(methodName);
g.setAccessible(true);
g.invoke(a); // 将获得的方法g()重定位到a
}
}程序执行的结果是：
即使访问权限限制了使用者对类的直接访问，反射依旧提供了足以调用所有方法的能力，只需要我们知道类中方法的名字即可。
并且，即使我们只发布代码的已编译版本，JDK自带的反编译器依旧可以展示出文件中所有的成员。JDK的反编译命令如下：
javap -private C执行上述命令，可得到如下结果：
通过这种方式，任何人都可以看到被隐藏的方法或签名（并调用它们）。
即使内部私有类也不能例外：
【例子：利用反射访问私有内部类】
package reflection;
import reflection.interfacea.A;
class InnerA {
private static class C implements A {
@Override
public void f() {
System.out.println("public C.f()");
}
public void g() {
System.out.println("public C.g()");
}
void u() {
System.out.println("package C.u()");
}
protected void v() {
System.out.println("protected C.v()");
}
private void w() {
System.out.println("private C.w()");
}
}
public static A makeA() {
return new C();
}
}
public class InnerImplementation {
public static void main(String[] args)
throws Exception {
A a = InnerA.makeA();
a.f();
System.out.println(a.getClass().getName());
// 通过反射访问私有类内部：
HiddenImplementation.callHiddenMethod(a, "g");
HiddenImplementation.callHiddenMethod(a, "u");
HiddenImplementation.callHiddenMethod(a, "v");
HiddenImplementation.callHiddenMethod(a, "w");
}
}程序执行的结果是：
匿名类也是如此（代码结构与上面的大致相同）：
【例子：通过反射访问匿名类】
package reflection;
import reflection.interfacea.A;
class AnnoymousA {
public static A makeA() {
return new A() {
@Override
public void f() {
System.out.println("public C.f()");
}
public void g() {
System.out.println("public C.g()");
}
void u() {
System.out.println("package C.u()");
}
protected void v() {
System.out.println("protected C.v()");
}
private void w() {
System.out.println("private C.w()");
}
};
}
}
public class AnnoymousImplementation {
public static void main(String[] args)
throws Exception {
A a = AnnoymousA.makeA();
a.f();
System.out.println(a.getClass().getName());
// 通过反射访问匿名类内部：
HiddenImplementation.callHiddenMethod(a, "g");
HiddenImplementation.callHiddenMethod(a, "u");
HiddenImplementation.callHiddenMethod(a, "v");
HiddenImplementation.callHiddenMethod(a, "w");
}
}程序执行的结果是：
除此之外，也可以通过反射访问字段：
【例子：通过反射访问字段】
package reflection;
import java.lang.reflect.Field;
class WithPrivateFinalField {
private int i = 1;
private final String s = "这条语句是private final的";
private String s2 = "这条语句是private的";
@Override
public String toString() {
return "该类拥有的private字段如下：\n\t" +
"i = " + i + "\n\t" +
"s = " + s + "\n\t" +
"s2 = " + s2;
}
}
public class ModifyingPrivateFields {
public static void main(String[] args)
throws Exception {
WithPrivateFinalField pf =
new WithPrivateFinalField();
System.out.println(pf);
System.out.println("\n通过反射访问字段：");
// Field类可用于反射字段
Field field = pf.getClass().getDeclaredField("i");
field.setAccessible(true); // 允许访问
System.out.println("f.getInt(pf)："
+ field.getInt(pf));
field.setInt(pf, 47);
System.out.println("使用setInt()改变i的值，" + pf);
System.out.println("=====");
field = pf.getClass().getDeclaredField("s");
field.setAccessible(true); // 允许访问
System.out.println("f.get(pf)："
+ field.get(pf));
field.set(pf, "尝试改变s");
System.out.println("使用set()无法改变s的值，" + pf);
System.out.println("=====");
field = pf.getClass().getDeclaredField("s2");
field.setAccessible(true); // 允许访问
System.out.println("f.get(s2)："
+ field.get(pf));
field.set(pf, "不安全");
System.out.println("使用set()改变s的值，" + pf);
}
}程序执行的结果是：
不过final字段还是安全的，不会因为反射而反射变化。
一般而言，反射带来的麻烦不会有想象中的那么大，因为如果有人使用了反射，那么他们也应该承受代码改变带来的风险。并且，Java提供这样一个后门来访问类，确实可以解决一些问题。
注意：面向对象编程语言要求，在任何可能的地方使用多态，而只在必要的地方使用反射（若一定要使用，可以将反射放到一个特定的类中进行使用。但我们也可能找到一个更好的替代方案）。
