JavaSE之内部类

最新推荐文章于 2025-03-26 18:26:55 发布

最新推荐文章于 2025-03-26 18:26:55 发布 · 715 阅读

JAVA 基础知识专栏收录该内容

35 篇文章

订阅专栏

内部类分类：

成员内部类:在成员位置声明的类,叫成员内部类.

局部内部类：在局部变量定义的类,叫局部内部类.

1.成员内部类：

非静态成员内部类：//格式外部类名.内部类名对象名=new 外部类().new内部类();

package cn.itcast.inner;

public class InnerDemo2 {
	public static void main(String[] args) {
		//格式 外部类名.内部类名.内部类名.对象名=外部类对象.内部类对象
		OuterClass.InnerClass oi=new OuterClass().new InnerClass();
		oi.show();
	}
}
class OuterClass{
	private int num=10;
	class InnerClass{//成员函数内部类
		public void show(){
			System.out.println(num);
		}
	}
}

运行结果：10

2.静态成员内部类

格式：外部类名.内部类名对象名=new 外部类.内部类--->这里的内部类可以想象成外部类的静态成员变量

package cn.itcast.inner1;
public class InnerDemo1 {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer.Inner();
	}
}
 class Outer {
		private int num = 10;
		private static int num2 = 100;
		public static class Inner {
			public void show() {
				System.out.println(num2);//静态内部类只能调用静态的变量,不能调用非静态的变量
			}

			public static void show2() {
				System.out.println(num2);
			}		
		}
	}

3.局部内部类

package cn.itcast.inner2;

public class InnerDemo1 {
	public static void main(String[] args) {
		Outer o=new Outer();
		o.method();
	}
}
class Outer{
	private int num=10;
	public void method(){
		final int num2=20;
		class Inner{//这个是局部内部类,是在堆内存中的 不会立即消失
			public void show(){
				System.out.println(num);
				System.out.println(num2);//这里要使用num2必须使用final 因为使用final就变为常量了！
			}
		}
		Inner i=new Inner();
		i.show();//局部变量是随着方法的消失而消失 调用结束 num2的声明周期就结束
	}
}

局部内部类调用局部变量,局部变量必须声明为final!

(1).所谓“局部内部类”就是在对象的方法成员内部定义的类。而方法中的类，访问同一个方法中的局部变量，却必须要加上一个final。

(2).原因是编译程序实现上的困难：内部类对象的生命周期会超过局部变量的生命期。局部变量的生命期：当该方法被调用时，该方法中的局部变量在栈中被创建，当方法调用结束时，退栈，这些局部变量全部死亡。而内部类对象生命期，与其它类一样，当创建一个局部内部类对象后，只有当没有其它人再引用它时，它才能死亡。所以完全可能一个方法已调用结束（局部变量已死亡），但该局部类的对象仍然活着。即：局部类的对象生命期会超过局部变量。

(3).局部内部类的对象访问同一个方法中的局部变量，那么这就要求只要局部内部类对象还活着，那么栈中的那些它要访问的局部变量就不能“死亡”（否则：它都死了，还访问个什么呢？）。这就是说：局部变量的生命期至少等于或大于局部内部类对象的生命期。

(4).解决方法：局部内部类的对象可以访问同一个方法中被定义为final的局部变量。定义为final后，编译程序的实现方法：将所有的局部内部类对象要访问的final型局部变量，都拷贝成为该内部类对象中的一个数据成员。这样，即使栈中局部变量（含final）已死亡，但由于它是final,其值永不变，因而局部内部类对象在变量死亡后，照样可以访问final型局部变量。(这一点我有些怀疑)

(5).归纳总结：局部内部类对象中包含有要访问的final型局部变量的一个拷贝，成为它的数据成员。因此，正是在这个意义上，final型局部变量的生命期，超过其方法的一次调用。严格来说，方法调用结束，所有的局部变量（含final）全死亡了。但：局部内部类对象中有final型局部变量的拷贝。

final 补充说明：

1.在java中声明类、属性、方法时，可使用关键字final来修饰

2.final标记的类不能被继承。

3.final标记的方法不能被子类重写

4.final标记的变量（成员变量或局部变量）即成为常量，只能赋值一次。

5.final标记的变量必须在声明的同时或在构造方法中显示赋值，然后才能使用。

final int x = 5;

class Test{

final int x ;

Test(){

x=3;

} }

4.匿名内部类

package cn.itcast.inner2;

public class InterDemo {
	public static void main(String[] args) {
		OuterClass o=new OuterClass();
		o.method();
	}
}
interface Inter{
	public abstract void show();
	public abstract void show2();
}
class OuterClass{
	public void method(){
		/*new Inter() {
			@Override
			public void show2() {
				System.out.println("show2");
			}
			@Override
			public void show() {
				System.out.println("show");
			}
		}.show();
		new Inter() {
			@Override
			public void show2() {
				System.out.println("show2");
			}
			@Override
			public void show() {
				System.out.println("show");
			}
		}.show2();;*/
		//下面是解决方案
		Inter inter=new Inter() {
			@Override
			public void show2() {
				System.out.println("show2");
			}
			@Override
			public void show() {
				System.out.println("show");
			}
		};
		inter.show();
		inter.show2();
	}
}

为了解决代码的重复性,建议使用下面的方式调用方法！Inter inter=new Inter(){...}后面new的是接口的实现类！实际上就是多态！