定义
定义在一个类里面的类就叫内部类。
作用
1、内部类可以很好的隐藏实现；
一般的非内部类，是不允许有 private 与protected权限的，但内部类可以
2、内部类可以实现多重继承；
3、内部类拥有外部类的所有访问权限；
4、可以避免父类和接口同方法名时的覆盖问题。
解析
1、内部类可以很好的隐藏实现；
由于外部类是不允许定义为private或者protected类型的，所以如果我们要隐藏一些我们实现细节，就可以通过内部类来实现，比如支付是比较核心的功能，需要尽可能的隐藏其实现细节，调用者只需要能够使用即可，如下：
public interface IPay{
void pay();
}
public class Payer1 {
private class PayImpl implements IPay{
public void pay() {
System.out.println("pay ing...");
}
}
public IPay startPay() {
return new PayImpl();
}
}
class TestPay {
public static void main(String[] args) {
Payer1 pm = new Payer1();
IPay p = pm.startPay();
p.pay();
}
}
上面的PayImpl定义在内部类中，用private修饰符来控制访问权限。在后面的main方法中，直接通过IPay.pay()方法进行操作，外部调用者甚至连该实现类的名字都没有看见，这样就可以尽可能的隐藏实现细节，体现java的封装性。
2、内部类可以实现多重继承；
现实世界中是存在多重继承关系的，比如，孩子既继承父亲也继承母亲的基因，父亲会work，母亲会dancing，孩子继承了父母的所有这些基因。在java代码中该如何表示呢？由于在java中一个类只支持单继承，多实现，但是对于这种场景，用接口来定义父亲和母亲似乎不太合理，所以这时候内部类就发挥其作用了：
public class father {
void work(){...}
}
public class mother{
void dancing(){...}
}
public class Child {
public static void main(String args[])
{
Child child=new Child ();
child.work();
child.dancing();
}
public void work(){
InnerChild1 child1 = new InnerChild1 ();
child1.work();
}
public void dancing(){
InnerChild2 child2 = new InnerChild2 ();
child2.dancing();
}
private class InnerChild1 extends father{
void work() {
super.work();
}
}
private class InnerChild2 extends mother{
void dancing() {
super.dancing();
}
}
}
这样孩子便继承了父母的优秀基因，可谓才艺双馨。
3、内部类拥有外部类的所有访问权限
由于非静态内部类会持有外部类的引用，因此，非静态内部类可以访问外部类的所有属性及方法，这样可以为程序的设计带来极大的灵活性。对第一段代码稍作修改：
public interface IPay{
void pay();
}
public class Payer1 {
private double money;
private class PayImpl implements IPay{
public void pay() {
money --;
System.out.println("pay ing...");
}
}
public IPay startPay() {
return new PayImpl();
}
}
class TestPay {
public static void main(String[] args) {
Payer1 pm = new Payer1 ();
IPay p = pm.startPay();
p.pay();
}
}
我们在外部类中新增了一个用private修饰的money字段，然后在内部类PayImpl 调用pay方法时，修改了该字段的值，这样可以直接通过内部类来访问外部类。
4、可以避免父类和接口同方法名时的覆盖问题
试想一下，如果你的类要继承一个类，还要实现一个接口，可是你发觉你继承的类和接口里面有两个同名的方法该怎么办？你怎么区分它们？你可能会说，我改成不同名的不就完事了吗，多大点事？如果这个父类和接口你都能改的话，确实可以这样做，但是有没有办法在不改的前提下解决这个问题呢，或者说你根本就没有机会改，比如，他们是你引入的第三方SDK呢，你该咋办？ 这时候就需要我们实现内部类了：
public class Payer{
void pay(){
System.out.println("Payer implement...");
}
}
public interface IPay{
void pay();
}
//上面部分中Payer类和IPay接口有相同的方法pay()，然后我们有如下实现方法：
public class Payer1 extends Payer implements IPay{
@override
public void pay() {
System.out.println("pay ing...");
}
}
// 想问一下大家pay()这个方法是属于覆盖Payer这里的方法呢？还是IPay这里的方法。我怎么能调到Payer这里的方法？显然这是不好区分的。而我们如果用内部类就很好解决这一问题了。看下面代码
public class Payer1 extends Payer {
private class InnerPayer implements IPay {
public void pay() {
Payer1.this.pay();
}
}
IPay startPay() {
return new InnerPayer ();
}
}
class TestPay {
public static void main(String[] args) {
Payer1 pm = new Payer1 ();
IPay p = pm.startPay();
p.pay();
}
}
这样就完美的解决了同名方法覆盖的问题。
