Java基础教程——内部类

内部类

内部类（inner class）是定义在另一个类中的类

内部类的好处：

|--1.隐藏机制:内部类封装性更好，隐藏在一个类之中，同一包中的其他类也不能访问

|--2.内部类可以访问外围类的私有数据

成员内部类

member inner class

可以访问外部类的所有成员变量和方法（无论静态、非静态)

自身没有静态成员

|--外部类里面创建成员内部类的实例：this.new Innerclass();

|--在外部类之外创建内部类的实例：new Outerclass().new Innerclass();

|--在内部类里访问外部类的成员：Outerclass.this.member

class Hero {
	void callHorse() {
		// 自己使用自己的成员内部类
		System.out.print("吕布");
		this.new Horse().show();
	}
	// 成员内部类
	class Horse {
		public void show() {
			System.out.println("---赤兔---");
		}
	}
}
public class InnerClassMember {
	public static void main(String[] args) {
		Hero h = new Hero();
		h.callHorse();
		// 创建一个类的内部类
		Hero.Horse horse = new Hero().new Horse();
		horse.show();
	}
}

吕布---赤兔---
---赤兔---

静态内部类

static inner class (nested class)

使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围对象，可以将内部类声明为static。

生成静态内部类对象的方式为：

OuterClass.InnerClass inner = new OuterClass.InnerClass();// 里面的类不用new

|--成员内部类没有静态成员；

|--静态内部类只能访问外围类的静态成员

局部内部类

local inner class

在方法中定义、使用

不能被public, protected, private和static修饰(像局部变量一样)

只能访问方法中定义的final类型的局部变量(初始化之后便不能更改)

import java.util.*;
// 以集合排序需要实现Comparator接口为例
public class TestInnerClassLocal {
	public static void main(String[] args) {
		class InnerComparator implements Comparator<Integer> {
			@Override
			public int compare(Integer o1, Integer o2) {
				return o2 - o1;
			}
		}
		// 需要先定义局部内部类，再使用
		InnerComparator com = new InnerComparator();
		List<Integer> lst = new ArrayList<>();
		Collections.addAll(lst, 2, 3, 5, 1, 4);
		Collections.sort(lst, com);
		System.out.println(lst);
	}
}

[5, 4, 3, 2, 1]

匿名内部类

anonymous inner class

没有名字的局部内部类。

用于只创建这个类的一个对象的场合（不必命名），通常是作为方法的参数

隐式地继承了一个父类或者实现了一个接口

限制：由于构造方法的名字与类名相同，而匿名类没有类名，所以，匿名类不能有构造方法。

综合代码：

import java.util.Date;
class OutClass {
	private static String field_Static = "外围类：静态变量";
	private String field_Common = "外围类：普通变量";
	private static void methodStatic() {
		System.out.println("外围类：静态方法");
	}
	private void methodCommon() {
		System.out.println("外围类：普通方法");
	}
	// 成员内部类
	class InnerClassMember {
		// Err:
		// private static String inner_fieldStatic = "内部类：静态变量";
		private String inner_fieldCommon = "|---内部类：普通变量";
		// Err:
		// private static void innerMethodStatic() {}
		private void innerMethodCommon() {
			System.out.println("|---内部类：普通方法");
		}
		public void methodInner() {
			// 变量·外
			System.out.println(OutClass.this.field_Common);
			System.out.println(field_Static);
			// 变量·内
			System.out.println(inner_fieldCommon);
			// 方法·外
			methodStatic();
			OutClass.this.methodCommon();
			// 方法·内
			innerMethodCommon();
		}
	}
	// 静态内部类
	static class InnerClassStatic {
		private static String inner_fieldStatic = "|---静态内部类：静态变量";
		private String inner_fieldCommon = "|---静态内部类：普通变量";
		private static void innerMethodStatic() {
			System.out.println("|---静态内部类：静态方法");
		}
		private void innerMethodCommon() {
			System.out.println("|---静态内部类：普通方法");
		}
		public void methodInner() {
			// 变量·外
			System.out.println(OutClass.field_Static);
			// 变量·内
			System.out.println(inner_fieldCommon);
			System.out.println(inner_fieldStatic);
			// 方法·外
			OutClass.methodStatic();
			// 方法·内
			innerMethodStatic();
			innerMethodCommon();
		}
	}
	// 局部內部類
	public void method4InnerClassLocal() {
		String localField = "局部变量";
		final String localFieldFinal = "局部变量(final)";
		// ↑Java 8中不用加final，但局部内部类中不能修改其值
		// 局部内部类
		class InnerClassLocal {
			public void localClassM() {
				// Err: System.out.println(localField);
				System.out.println(localFieldFinal);
				System.out.println(field_Common);
				System.out.println(field_Static);
				methodCommon();
				methodStatic();
			}
		}
		InnerClassLocal _local_in_c = new InnerClassLocal();
		_local_in_c.localClassM();
	}
	// --------------------
	public void testAnonymousClass() {
		// 匿名内部类
		PrintDate(new Date() {
			public long getTime() {
				System.out.println(field_Common);
				System.out.println(field_Static);
				methodCommon();
				methodStatic();
				return 10086;
			}
		});
	}
	private void PrintDate(Date dt) {
		System.out.println(dt.getTime());
	}
}
public class InnerClassTest1 {
	public static void main(String[] args) {
		System.out.println("===↓↓↓成员内部类===================");
		OutClass.InnerClassMember ic = new OutClass().new InnerClassMember();
		ic.methodInner();
		System.out.println("===↓↓↓静态内部类===================");
		OutClass.InnerClassStatic ics = new OutClass.InnerClassStatic();
		ics.methodInner();
		System.out.println("===↓↓↓局部内部类===================");
		OutClass oc = new OutClass();
		oc.method4InnerClassLocal();
		System.out.println("===↓↓↓匿名内部类===================");
		oc.testAnonymousClass();
	}
}

===↓↓↓成员内部类===================
外围类：普通变量
外围类：静态变量
|---内部类：普通变量
外围类：静态方法
外围类：普通方法
|---内部类：普通方法
===↓↓↓静态内部类===================
外围类：静态变量
|---静态内部类：普通变量
|---静态内部类：静态变量
外围类：静态方法
|---静态内部类：静态方法
|---静态内部类：普通方法
===↓↓↓局部内部类===================
局部变量(final)
外围类：普通变量
外围类：静态变量
外围类：普通方法
外围类：静态方法
===↓↓↓匿名内部类===================
外围类：普通变量
外围类：静态变量
外围类：普通方法
外围类：静态方法
10086

对比和总结

面试题

面试题：

1、静态内部类和成员内部类有什么不同？（美团）

2、Anonymous Inner Class (匿名内部类)是否可以继承其它类，是否可以implements(实现)interface(接口)?

3、补全代码：

interface Inter {
	public void show();
}
class Outer {
	public static Inter method() {// 返回值是接口的方法
		// 补全代码↓↓↓
		return
		// 补全代码↑↑↑
	}
}
public class OuterDemo {
	public static void main(String[] args) {
		Outer.method().show();
	}
}