Java基础-内部类

骑牛小道士

已于 2025-04-09 22:26:18 修改

阅读量225

点赞数

文章标签： java

于 2022-11-28 00:25:18 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_44891364/article/details/128072418

版权

内部类

什么是内部类
内部类的分类
内部类如果引用局部变量变量必须要加上final
类执行顺序相关

什么是内部类

在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。

内部类的优点

一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据！
内部类不为同一包的其他类所见，具有很好的封装性；
内部类有效实现了“多重继承”，优化 java 单继承的缺陷。
匿名内部类可以很方便的定义回调。

内部类有哪些应用场景

一些多算法场合
解决一些非面向对象的语句块。
适当使用内部类，使得代码更加灵活和富有扩展性。
当某个类除了它的外部类，不再被其他的类使用时。

内部类的分类

内部类可以分为四种：成员内部类、局部内部类、匿名内部类和静态内部类

静态内部类

静态内部类：定义在类内部的静态类，就是静态内部类

静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；静态内部类的创建

public class Outer {
	// 定义在类中的静态变量
	private static int a = 1;
	// 定义在类中的成员变量
	private int b = 1;
	
	//关键字static
	static class StaticInner {
		public void visit() {
		//静态内部类可以访问外部类的静态变量，不可访问外部类的非静态变量
		System.out.println("outer static variable:" + a);
		//报错 Non-static field 'b' cannot be referenced from a static context
		System.out.println("outer variable:" + b);
		}
	}
	// 静态内部类的引用
	Outer.StaticInner inner = new Outer.StaticInner();
	inner.visit();
}

成员内部类

成员内部类：定义在类内部非静态的类，就是成员内部类

成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公有

public class Outer {
	private static int radius = 1;
	private int count =2;
	class MemberInner {
		public void visit() {
		//成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公有
			System.out.println("visit outer static variable:" + radius);
			System.out.println("visit outer variable:" + count);
			}
		}
	// 成员内部类的引用
	Outer.MemberInner memberInner= new outer.Inner();
	inner.visit();
}

局部内部类

局部内部类:定义在方法中(局部中)的内部类，就是局部内部类

定义在方法中的内部类，有两种:定义在静态方法中和非静态方法中的内部类
1.定义在普通实例方法中的局部内部类

public class StaticInClass {

    public static String a = "1";
    public String b = "c";

    public void test(){
        class Part{
            private void fun(){
            	//可以引用静态和非静态变量
                System.out.println(a);
                System.out.println(b);
            }
        }
        // 普通局部内部类只能在方法里面实例化
        Part part = new Part();
        part.fun();
    }
 }

2.定义在静态实例方法中的局部内部类

public class StaticInClass {

    public static String a = "1";
    public String b = "c";

    public static void test(){
        class Part{
            private void fun(){
                //定义在静态方法中的局部类只能访问外部类的静态变量和方法
                System.out.println(a);
                //报错 Non-static field 'b' cannot be referenced from a static context
                System.out.println(b);
            }
        }
        Part part = new Part();
        part.fun();
    }
   }

匿名内部类

匿名内部类:匿名内部类就是没有名字的内部类，就是在类里面直接 new一个接口重写该接口方法

匿名内部类必须继承或实现一个已有的接口

	interface Service{
		void method();
	}

接口不能实例化的，我们需要使用某个接口的方法，直接通过new接口重写该接口方法，注意这里new但不是对接口进行实例化，隐藏了类名和构造方法，所以叫匿名内部类

    //当所在的方法的形参如果需要被匿名内部类使用时，必须声明为final
	private void test(final int i) {
		new Service() {
		//	匿名内部类不能定义任何静态成员和静态方法。
			public void method() {
				for (int j = 0; j < i; j++) {
					System.out.println("匿名内部类" );
					}
				}
			}.method();	//匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法
		}
	}

除了没有名字，匿名内部类还有以下特点：
①匿名内部类必须继承一个抽象类或者实现一个接口。
②匿名内部类不能定义任何静态成员和静态方法。
③当所在的方法的形参需要被匿名内部类使用时，必须声明为 final。
④匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法

匿名内部类创建方式：

new 抽象类/接口{
	匿名内部类实现部分
}

内部类如果引用局部变量变量必须要加上final

public class Outer {
	void outMethod(){
	//变量必须要加上final
		final int a =10;
		
		class Inner {
			void innerMethod(){
				System.out.println(a);
			}
		}
	}
}