内部类

最新推荐文章于 2021-02-21 05:38:58 发布

原创最新推荐文章于 2021-02-21 05:38:58 发布 · 317 阅读

1 ·

CC 4.0 BY-SA版权

Java基础专栏收录该内容

12 篇文章

订阅专栏

在Java中有一种特殊的语法。就是一个类的内部定义一个类，那么就成为这个类为内部类，外层的就叫做外部类(外围类)。根据内部类在外部类中所处的位置不同，可将内部类分为局部内部类和成员内部类。

局部内部类：定义在外部类方法体内的内部类
成员内部类：定义在外部类方法体外的内部类

正如成员变量有静态和非静态之分，那么成员内部类也分为静态内部类和实例内部类。而两者最大的区别就是：实例内部类的对象实例，必须在有定义它的外部类对象实例存在的情况下才能创建。静态内部类对象创建实例则不受此限制。实例内部类中不能定义静态成员，而静态内部类则可以定义任意形式的成员。

内部类的使用

外部类和外部类都是相对而言的，因为内部类是可以多次嵌套的，使用内部类我们应该注意下面的问题

顶级类只有两种访问权限即public和默认的，而内部类有4中访问权限 public , protected , 默认 , private
内部类不能和外部类重名

class Outer{
	private String str = "外部类的私有属性str";
	
	public class Inner{
		public void say() {     //定义内部类的方法
			System.out.println("我是内部类Inner");
		}
		public void getStr() {
			System.out.println(str);   //定义内部类的方法,获取外部类的私有属性
		}
	}
	public void getInfo() {
		new Inner().getStr();    //直接实例化内部类对象并调用其方法
	}
}
public class Demo {
	public static void main(String[] args) {
		Outer outer = new Outer();   //创建外部类实例
		outer.getInfo();   //调用外部类方法
		
		Outer.Inner inner = new Outer().new Inner();   //创建内部类实例，需要通过内部类的完整类名来访问
		inner.say();     //调用内部类方法
	}
}

外部类的私有属性str
我是内部类Inner

下面我们看一下把内部类放到外面这种情况

class Outer{
	private String str = "外部类的私有属性str";
	
	
	public String getStr() {
		return str;
	}
	public void setStr(String str) {
		this.str = str;
	}


	public void getInfo() {    //调用Inner类的getStr()方法
		new Inner().getStr();    
	}
}	
class Inner{
	private Outer outer;
	
	public void say() {     //定义内部类的方法
		System.out.println("我是内部类Inner");
	}
	public void getStr() {
		System.out.println(new Outer().getStr());   //定义内部类的方法,获取外部类的私有属性
	}
}

public class Demo {
	public static void main(String[] args) {
		Outer outer = new Outer();   //创建外部类实例
		outer.getInfo();     //调用外部类方法
		
		Inner inner = new Inner();   //创建内部类实例
		inner.say();     //调用内部类方法
	}
}

外部类的私有属性str
我是内部类Inner

从程序的运行结果可以看出来，所实现的功能是相同的。上个例子我们内部类在外部类的内部，那么内部类可以直接访问外部类的private属性。而下面的这个程序，内部类在外部类的外面，所以需要通过外部类的方法getStr()访问私有属性。

静态内部类

静态内部类是声明在外部类中，作为外部类的静态成员的内部类，即用static关键字修饰的内部类，遵守类的静态成员所应遵守的规则，比如不能访问外部类的非静态成员。静态内部类无法直接存取外部类的非静态成员，若需要访问，应该创建外部类的对象，再用该对象去调用外部类的非静态成员

class Outer{
	private int a = 66;
	private static int b = 99;
	
	public static class Inner{   //定义静态内部类
		private int x = 6;
		private static int y = 9;
		
		public void add(){  //定义实例方法
			int aa = new Outer().a;        //通过外部类的实例对象调用外部类的非静态成员
			System.out.println(aa+"+"+x+"="+(aa+x));
		}
		
		public static void mul(){
			System.out.println(b+"*"+y+"="+(b*y));   //直接调用外部类的成员
		}
	}

	public void getInfo(){
		new Inner().add();   //通过内部类对象访问静态内部类的非静态方法
		Inner.mul();       //直接通过"静态内部类名.静态方法"形式访问静态内部类的静态方法
	}
}
public class Demo{
	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.getInfo();
		
		Outer.Inner inner = new Outer.Inner();   //创建内部类实例
		inner.add();
		inner.mul();
	}
}

66+6=72
99*9=891
66+6=72
99*9=891

从上面的程序可以发现，静态内部类可以直接调用外部类的静态成员，包括私有的静态成员。但是如果要访问外部类的非静态成员时，需要通过外部类的实例访问。

局部内部类

局部内部类是指定义在方法体内的捏不累，局部内部类仅在该方法里面有效。因此，局部内部类不能被外部类和外部类以外的其他类访问，所以局部内部类是不需要访问控制符和static修饰的。

class Outer{
	public void fun(){
		class Inner{
			public int a = 10;
		}
		Inner inner = new Inner();
		System.out.println(inner.a);
	}
}
public class Demo{
	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.fun();    //10
	}
}

使用局部内部类需要注意事项：