阿里Java学习路线：阶段 1：Java语言基础－Java面向对象编程：第28章：内部类基本概念：课时127：内部类相关说明

现在已经清楚的认识到了内部类的优势以及结构，那么随后需要对内部类进行一些相关的说明，现在所定义的内部类都属于普通的内部类的形式，普通的类内部往往会提供有属性和方法，需要注意的是，内部类虽然可以方便的访问外部类中的私有成员或私有方法，同理，外部类也可以轻松访问内部类中的私有成员或私有方法。
范例：外部类访问内部类中的私有属性

class Outer { // 外部类
	private String msg = "www.mldn.cn" ; // 私有成员属性
	public void fun() { // 普通方法
		Inner in = new Inner() ; // 实例化内部类对象
		in.print() ; // 调用内部类方法
		System.out.println(in.info); // 访问内部类的私有属性
	}
	class Inner { // 在Outer类的内部定义了Inner类
		private String info = "今天天气不好，收衣服啦！";
		public void print() {
			System.out.println(Outer.this.msg) ; // Outer类中的属性
		}
	}
}
public class JavaDemo {
	public static void main(String args[]) {
		Outer out = new Outer() ; // 实例化外部类对象
		out.fun(); // 调用外部类中的方法
	}
}

使用了内部类之后，内部类与外部类之间的私有操作的访问就不再需要通过setter、getter以及其它的间接方式完成了，可以直接进行处理操作。
但是需要注意的是，内部类本身也属于一个类，虽然在大部分的情况下内部类往往是被外部类包裹的，但是外部依然可以产生内部类的实例化对象，而此时内部类实例化对象的格式如下：

外部类.内部类 内部类对象 ＝ new 外部类().new 内部类() ;

在内部类编译完成之后会自动开成一个“Outer$Inner.class”类文件，其中“ $ ”这个符号换到程序之中就变成了“ . ”，所以内部类的全称：“外部类.内部类”。内部类与外部类之间可以直接进行私有成员的访问，这样一来内部类如果要是提供有实例化对象了，一定要先保证外部类已经实例化了。

class Outer { // 外部类
	private String msg = "www.mldn.cn" ; // 私有成员属性
	class Inner { // 在Outer类的内部定义了Inner类
		private String info = "今天天气不好，收衣服啦！";
		public void print() {
			System.out.println(Outer.this.msg) ; // Outer类中的属性
		}
	}
}
public class JavaDemo {
	public static void main(String args[]) {
		Outer.Inner in = new Outer().new Inner() ;
		in.print(); 
	}
}

如果此时Inner类只允许Outer类来使用，那么在这样的情况下就可以使用private进行私有定义。

class Outer { // 外部类
	private String msg = "www.mldn.cn" ; // 私有成员属性
	private class Inner { // 在Outer类的内部定义了Inner类
		private String info = "今天天气不好，收衣服啦！";
		public void print() {
			System.out.println(Outer.this.msg) ; // Outer类中的属性
		}
	}
}

此时的Inner类无法在外部进行使用。
在Java之中类作为最基础的结构体实际上还有与之类似的抽象类或者是接口，抽象类与接口中都可以定义内部结构。
范例：定义内部接口

interface IChannel { // 定义接口
	public void send(IMessage msg) ; // 发送消息
	interface IMessage { // 内部接口
		public String getContent() ; // 获取消息内容
	}
}
class ChannelImpl implements IChannel {
	public void send(IMessage msg) {
		System.out.println("发送消息：" + msg.getContent());
	}
	class MessageImpl implements IMessage {
		public String getContent() {
			return "www.mldn.cn";
		}
	}
}
public class JavaDemo {
	public static void main(String args[]) {
		IChannel channel = new ChannelImpl() ;
		channel.send(((ChannelImpl)channel).new MessageImpl());
	}
}

下面继续观察一个内部的抽象类，内部抽象类可以定义在普通类、抽象类、接口内部都是可以的。
范例：观察部内抽象内

interface IChannel { // 定义接口
	public void send() ; // 发送消息
	abstract class AbstractMessage {
		public abstract String getContent() ;
	}
}
class ChannelImpl implements IChannel {
	public void send() {
		AbstractMessage msg = new MessageImpl() ;
		System.out.println(msg.getContent()) ;
	}
	class MessageImpl extends AbstractMessage {
		public String getContent() {
			return "www.mldn.cn";
		}
	}
}
public class JavaDemo {
	public static void main(String args[]) {
		IChannel channel = new ChannelImpl() ;
		channel.send();
	}
}

内部类还有一些更为有意思的结构，即：如果现在定义了一个接口，那么可以在内部利用类实现该接口。在JDK1.8之后接口中追加了static方法可以不受到实例化对象的控制，现在就可以利用此特性来完成功能。
范例：接口内部进行接口实现

interface IChannel { // 定义接口
	public void send() ; // 发送消息
	class ChannleImpl implements IChannel {
		public void send () {
			System.out.println("www.mldn.cn");
		}
	}
	public static IChannel getInstance() {
		return new ChannelImpl() ;
	}
}
public class JavaDemo {
	public static void main(String args[]) {
		IChannel channel = IChannel.getInstance() ;
		channel.send();
	}
}

内部类是一种非常灵活的定义结构，只要你的语法满足了，各种需求都可以帮你实现。