java内部类的作用（二）----隐藏作用
1.局部类的隐藏作用
局部内部类：是指在方法函数中去定义一个内部类。
局部内部类有一个优势：即对外部世界完全可以隐藏起来，在这个方法类中的其它方法或者代码都不能调用这个内部类。更不用说其它的类了
也就是局部内部类的作用域只在申明它的块中有效。
除了该方法，没有任何其他的方式知道这个类的存在。
看看代码给出的例子：
<span style="font-size:18px;"><strong>package org.innerclass.operate;
public class LocalInnerClassTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
start();
findInnerClass();
}
public static void start()<span style="color:#ff0000;">{</span>
<span style="color:#33cc00;">class A</span>{
public void print(){
System.out.println("我是内部类A的一个方法，任何人都都休想访问我，我对外部世界是完全隐藏的，只有start()方法有权限操作我");
}
}
A a = new A();
a.print();
<span style="color:#ff0000;">}</span>
public static void findInnerClass(){
System.out.println("对不起，我不能直接访问内部类A，如果想要访问，我必须先经过start(),我必须拥有调用start()的方法的权限");
}
}</strong></span>内部类 class A的作用域被限定在{ }表示的块中
局部内部类不能用public或者private访问说明符进行声明。
注意：一般局部内部类只有在当整个应用程序代码中使用了一次的时候，就可以放在局部中。
当然也可以根据它的这个隐藏的作用去设置自己的代码。因为局部内部类只有定义它的方法知道，其他的人都无权干涉。
2.内部类的对象总有一个隐式引用，它指向了创建它的外部类对象。
可以访问外部类的数据和方法，包括私有数据
看看代码说明：
package org.innerclass.operate;
public class InnerClassAcessOuterClassData {
private int a = 5;
public int b = 5;
public String print(){
return "我是外围类的public方法";
}
public class A{
public A(){
innerprint();
}
public void innerprint(){
System.out.println("我是内部类的方法，我可以访问外围类的public变量"+b);
System.out.println("我是内部类的方法，我可以访问外围类的private变量"+a);
System.out.println("我是内部类的方法,我可以访问外围类的public函数--------"+print());
}
}
public void constructA(){
new A();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
InnerClassAcessOuterClassData test =new InnerClassAcessOuterClassData();
test.constructA();
}
}
在这个代码中我没有使用任何的static关键字。接下来我们来看看static有什么区别？、
直接看图：
主函数中，我们直接使用constructA（）；它提示我们该方法不是静态的，我们就去改成静态的：
当我们把这个方法改成静态的，它有告诉我出错了，这个错误的处理办法就是把A改成静态内部类，我们就去改
那么我们再去改：
源码：
package org.innerclass.operate;
public class InnerClassAcessOuterClassData {
private static int a = 5;
public static int b = 5;
public static String print(){
return "我是外围类的public static 方法";
}
public static class A{
public A(){
innerprint();
}
public void innerprint(){
System.out.println("我是静态内部类的方法，我可以访问外围类的public static 变量"+b);
System.out.println("我是静态内部类的方法，我可以访问外围类的private staic 变量"+a);
System.out.println("我是静态内部类的方法,我可以访问外围类的public static 函数--------"+print());
}
}
public static void constructA(){
new A();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
constructA();
}
}这个时候就没有出错了：
这给我们说明了什么问题呢：
它告诉我们，当我们使用静态内部类的时候，它可以取消隐式引用的作用，如果想这个隐式引用有效，必须改变外部类的数据或者方法为static才可以。
3.隐藏的作用体现在：内部类可以对同一个包中的其他类隐藏起来
这个很好解释，我们只可以用谁定义了这个内部类的外部类去使用这个内部类
直接看代码，标注的红色的部分：
定义内部类的类：
package org.innerclass.operate;
public class ArrayAlg {
public static class Pair{
private double first;
private double second;
public Pair(double f,double s){
first = f;
second = s;
}
public double getFirst() {
return first;
}
public double getSecond() {
return second;
}
}
public static Pair minmax(double[] values){
double min = Double.MAX_VALUE;
double max = Double.MIN_VALUE;
for(double v :values){
if(min > v) min = v;
if(max < v) max = v;
}
return new Pair(min,max);
}
}测试内部类的类：
package org.innerclass.operate;
public class StaticInnerClassTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
double[] d = new double[20];
for(int i =0;i<d.length;i++){
d[i]=100 * Math.random();
<span style="color:#ff0000;">ArrayAlg.Pair</span> p = ArrayAlg.minmax(d);
System.out.println("min"+p.getFirst());
System.out.println("max"+p.getSecond());
}
}
}看红色的代码，你是不能直接这样写的：Pair p = ArrayAlg.minmax(d);
