内部类可以声明为private和public，对其访问的限制与属性和方法并无差别。
个人觉得内部类有四个功能：
1，实现隐藏：
public class TestJava{
}
interface InF01{
void inFFunction01();//abstract function shouldn't have a code block;
}//inF01
class Outer{
//InnerClass has the same status as other types' attitude or function.
//In this case I set the InnerClass as a private variable.
private class Inner implements InF01{ //The InnerClass has implements The Interface01
public void inFFunction01(){
System.out.println("Interface01 has been implemented by InnerClass!");
System.out.println("Testing in the InnerClass!");
}
}//Inner
public InF01 getInnerObj(){
return new Inner();
}
}//Outer
class Demo{
public static void main(String[] args){
Outer obj = new Outer();
InF01 instance = obj.getInnerObj();
instance.inFFunction01();
}
}//Demo输出：
Interface01 has been implemented by InnerClass!
Testing in the InnerClass!
本例子中，用内部类实现了接口InF01，不过在main方法调用时，很明显用户不会知道有关Inner的任何信息。
只知道用inFFunction就能得到想要的输出结果。接口中的方法在实现接口的内部类中被覆盖。
想要调用内部类中实现了接口功能的函数，需要通过外部类创建外部实例obj，通过obj的getInnerObj方法的到内部实例化对象。
得到内部实例化对象后，调用接口方法，本质上就是内部实例化对象调用其实现的接口的覆盖后的方法。
2.访问权限
由于内部类在外部类中与外部类的成员和方法处于同等地位，所以内部类可以访问外部类任意权限的属性和方法。
public class TestJava{
}
class Person{
private String name = "FangXy";
private class PrintInfo{ //class PrintInfo{} not class PrintInfo(){} remember!!!
public PrintInfo(){
//cannot use this.name,there's no object after all.
System.out.println("Name is "+name);
}//Constructor of PrintInfo
}//PrintInfo
public void test(){
new PrintInfo();
}
}//Person
class Demo{
public static void main(String[] args){
Person per = new Person();
per.test();
}
}//Demo输出：
Name is FangXy
3.如果一个类同时继承了一个类并实现了一个接口，而父类和接口中又存在同名方法？子类中执行同名方法的话
究竟是父类中的同名方法被执行还是接口的同名方法被执行尼？（继承优先于实现，父类被执行）。不管谁被执行，
对代码的可读性都很差。用内部类可以解决这一问题。（父类和接口有同名方法的问题）
public class TestJava{
}
interface InterfaceTest{
void functionSameName();
}
class FatherClass {
public void functionSameName(){
System.out.println("FunctionSameName() from FatherClass is running!");
}
}
class SonClass extends FatherClass{
private class Inner implements InterfaceTest{
public void functionSameName(){
System.out.println("FunctionSameName() from InterfaceTest is running!");
}
}
InterfaceTest getInner(){
return new Inner();
}
}
class Demo{
public static void main(String[] args){
SonClass sobj01 = new SonClass();
InterfaceTest instance = sobj01.getInner();
instance.functionSameName();
SonClass sobj02 = new SonClass();
sobj02.functionSameName();
}
}//Demo输出
FunctionSameName() from InterfaceTest is running!
FunctionSameName() from FatherClass is running!
4.内部类可以实现多重继承，个人认为它是内部类存在的最大理由之一。正是由于内部类的存在使得Java的继承机制更加完善。大家都知道Java只能继承一个类，多重继承在没有学习内部类之前是用接口来实现的。不过使用接口有时实现多继承有时也很不方便，毕竟实现接口需要实现里面所有的方法。
而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。
public class TestJava{
}
class Name{
String name = "FangXy";
public String getName(){
return this.name;
}
}
class Age{
int age = 25;
public int getAge(){
return this.age;
}
}
class Person{
private class InnerName extends Name{
public String getName(){
return super.getName();
}
}
private class InnerAge extends Age{
public int getAge(){
return super.getAge();
}
}
public String getName(){
return new InnerName().getName();
}
public int getAge(){
return new InnerAge().getAge();
}
}
class Demo{
public static void main(String[] args){
Person per = new Person();
System.out.println("Name:"+per.getName());
System.out.println("Age:"+per.getAge());
}
}//Demo
本例在Person类中分别建立内部类InnerName和InnerAge来继承Name和Age类，间接实现了多继承，从而使Person可以任意访问Name类和Age类的所有属性和方法。覆盖父类方法用super.方法名（参数）。
输出：
Name:FangXy
Age:25