JAVA内部类的作用

定义

定义在一个类里面的类就叫内部类。

作用

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();  
    }  
}  

这样就完美的解决了同名方法覆盖的问题。