引入接口目的是把实现者和用户相分离，但是反射还是可以访问实现者

package：包,自己看成是文件夹。
package access : 就是一个文件夹下的类都可以相互调用。
目的：
     1、写了一个接口，里面有一些方法可以使用
     2、写了一个接口的实现类。
 不想其它的人员接触我的接口实现类，哪么使用了包访问。 
实现步骤：
  1、写一个接口：package ftypeinfo（包名）
  2、写接口实现类 ：ftypeinfo.packageaccess;（包名）
  3、接口使用类：package ftypeinfo;（包名和接口java文件放在一起）
  注：接口，接口使用类的java文件放在一个包里
         接口实现类：放入另一包里，并提供了一个方法和接口类相连接。
         所以接口使用类不能对接口实现类进行任何操作
一、接口
package ftypeinfo;
public interface A {
void f();
}
二、接口使用类，由于文件夹不一样，所以不能使用接口的实现类

      但是可以 import ftypeinfo.packageaccess.HiddenC;导入进来
     使用它的 public class下的方法。
package ftypeinfo;

import java.lang.reflect.Method;
import ftypeinfo.packageaccess.HiddenC;
public class HiddenImplementation {

public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
     A a=HiddenC.makeA();
     a.f();   
     //这里有点讽刺，本来不想外部的文件夹下的Java类使用
       但是当这个类运行时入内存后，使用RTTI,还是可以使用隐藏的方法，
         所以类中的一切（方法，类数据），不管是私有，保护，内部类，匿名类，类成员数据，
         RTTI全部可以使用，更改一个类里面的数据，自动调用其方法。
     callHiddenMethod(a,"g");
     callHiddenMethod(a,"u");
     callHiddenMethod(a,"v");
     callHiddenMethod(a,"w");
}
      //RTTI:可以得到运行时类的所有信息，并调用其方法。
     static void callHiddenMethod(Object a,String methodName)
     throws Exception{
    Method g=a.getClass().getDeclaredMethod(methodName);
    g.setAccessible(true);
        g.invoke(a);     
}
}

三、接口实现类：class C ,class 前面什么也没写，表示包访问，
      packageaccess 文件夹下的所有JAVA文件都能访问class C 里面的方法。其它文件夹不能访问。 
package ftypeinfo.packageaccess;

import ftypeinfo.A;
import static net.mindview.util.Print.*;
class C implements A{
public void f(){print("public c.f()");}
public void g(){print("public c.g()");}
    void u(){print("public c.u()");}
    protected void v(){print("public c.v()");}
    private void w(){print("public c.w()");}
}
public class HiddenC {
  //提供外部可直接调用的方法，只有放入接口实现类的对象，这个接口才真正可以使用。
   public static A makeA() {return new C();}
}