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);

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券