Java中的内部类

🐒个人主页：信计2102罗铠威

🏅JavaSE系列专栏

📖前言：

本篇博客主要以介绍Java中的内部类与lambda表达式

🎀什么是内部类

● 把类定义在另一个类的内部，该类就被称为内部类。
● 如果在类 Outer 的内部再定义一个类 Inner，此时类 Inner 就称为内部类
（或称为嵌套类），而类 Outer 则称为外部类（或称为宿主类）

🐕内部类的分类

● 内部类一般来说包括这四种：
成员内部类
静态内部类
局部内部类
匿名内部类
下面对它们进行一一介绍：

🧸成员内部类

成员内部类——就是位于外部类成员位置的类
特点：可以使用外部类中所有的成员变量和成员方法（包括private的）

class Outer {
	private int age = 20;
	class Inner {
		public void show() {
			System.out.println(age);
		}
	}
}
1
2
3
4
5
6
7
8

class Test {//另一个.java文件
public static void main(String[] ages) {
	Outer.Inner oi = new Outer().new Inner();
	oi.show();
}
}
1
2
3
4
5
6

● private修饰内部类
● 如果我们的内部类不想轻易被任何人访问，可以选择使用private修饰内部类，这
样我们就无法通过创建对象的方法来访问，想要访问只需要在外部类中定义一个
public修饰的方法，间接调用。这样做的好处就是，我们可以在这个public方法
中增加一些判断语句，起到数据安全的作用。

class Outer {
	private class Inner {
		public void show() {
			System.out.println(“密码备份文件”);
		}
	}
//使用getXxx()获取成员内部类，可以增加校验语句（文中省略）
public Inner getInner() {
	return new Inner();
	}
}
public static void main(String[] args) {
	Outer outer = new Outer();
	Outer.Inner inner = outer.getInner();
	inner.show();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

🧸静态内部类

这种被 static 所修饰的内部类，按位置分，属于成员内部类，但也可以称作静态内
部类，也常叫做嵌套内部类.不能使用外部类的非static成员变量和成员方法

public class Outter {
	int age = 10;
	static int age2 = 20;
	public Outter() {
	}
	static class Inner {
		public void method() {
			System.out.println(age);//错误
			System.out.println(age2);//正确
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

public class Test {
	public static void main(String[] args) {
		Outter.Inner inner = new Outter.Inner();
		inner.method();
	}
}
1
2
3
4
5
6

🧸局部内部类

局部内部类——就是定义在一个方法或者一个作用域里面的类
特点：主要是作用域发生了变化，只能在自身所在方法和属性中被使用

class Outrigger {
    public static void main(String[] args) {
        int a = 20;
        InnerClass inner = new InnerClass();
        inner.show();
        InnerClass.InnerInnerClass i = new InnerClass.InnerInnerClass();
        i.show();
    }

    static class InnerClass {
        int a2 = 30;

        void show() {
            System.out.println("a: " + a);
            System.out.println("a2: " + a2);
        }

        class InnerInnerClass {
            void show() {
                System.out.println("InnerInnerClass a2: " + a2);
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

🧸匿名内部类

4.匿名内部类
一个没有名字的类，是内部类的简化写法

interface Inner {
	public abstract void show();
	}
}
class Outer {
	publ ic void method(){
		new Inner() {
			public void show() {
				System.out.println("Hel loWorld");
			}
		}. show();
	}
}

class Test {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

🐕内部类的特点

● 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
● 内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否为 private 的。
● 内部类声明成静态的，就不能随便访问外部类的成员变量，仍然是只能访问外部类的静态成员变量

🐕内部类的意义

1.封装性

作为一个类的编写者，我们很显然需要对这个类的使用访问者的访问权限做出一
定的限制，我们需要将一些我们不愿意让别人看到的操作隐藏起来.

2.实现多继承