内部类

1）如果在一个类的内部再定义一个类，就是内部类，而外面的类叫外部类。

2）内部类可声明为public或private访问权限，对内部类的用法和限制与对成员变量和成员方法是相同的。

例子：

class Outer{        // 定义外部类
    private String info = "hello world" ;    // 定义外部类的私有属性
    class Inner{    // 定义内部类
        public void print(){                // 定义内部类的方法
            System.out.println(info) ;        // 直接访问外部类的私有属性
        }
    };
    public void fun(){                        // 定义外部类的方法
        new Inner().print() ;                // 通过内部类的实例化对象（匿名对象）调用方法
    }
};
public class InnerClassDemo01{
    public static void main(String args[]){
        new Outer().fun() ;                    // 调用外部类的fun()方法
    }
};

以上程序中，Inner作为内部类，并且在外部类的fun（）方法中直接实例化内部类对象，并调用print（）方法。

内部类存在的特点：

缺点：正常的类操作时，在类中最好只定义属性和方法。如果定义一个类的话，则肯定破坏了程序的结构。

优点：要想发现优点，通过代码拆分了解，将以上内部类和外部类变成两个类，再变成同样效果。

class Outer{        // 定义外部类
    private String info = "hello world" ;    // 定义外部类的私有属性
    public void fun(){                        // 定义外部类的方法
        new Inner(this).print() ;     // 通过内部类的实例化对象调用方法，
　　　//这里的this表示调用当前方法的对象，也就是主方法中的new Outer()匿名对象。
    }
    public String getInfo(){                // 增加了一个getter方法取得info内容
        return this.info ;    
    }
};
class Inner{    // 定义内部类
    private Outer out = null ;                // 声明Outer对象，用来接收传送过来的主方法中的new Outer()对象。
    public Inner(Outer out){　　　　　　　　　//Outer类中new Inner(this)，把主方法中的new Outer()匿名对象传递过来了，
        this.out = out ;
    }
    public void print(){                // 定义内部类的方法
        System.out.println(this.out.getInfo()) ;        // 直接访问外部类的私有属性
    }
};
public class InnerClassDemo02{
    public static void main(String args[]){
        new Outer().fun() ;                    // 调用外部类的fun()方法
    }
};

如果把内部类拿出去，会发现代码量增加，而且复杂度大大增加。

使用内部类最大优点：

可以方便的访问外部类中的私有属性。

但是，以上内部类是无法在外部直接调用的，是无法按照外部类形式使用的。

如：

class Outer{        // 定义外部类
    private static String info = "hello world" ;    // 定义外部类的私有属性
     class Inner{    
        public void print(){                // 定义内部类的方法
            System.out.println(info) ;        // 直接访问外部类的私有属性
        }
    };
    public void fun(){                        // 定义外部类的方法
        new Inner().print() ;                // 通过内部类的实例化对象调用方法
    }
};
public class InnerClassDemo03{
    public static void main(String args[]){
        new Outer.Inner().print() ;                    //无法直接调用外部类的fun()方法
    }
};

以上在外部是无法直接调用的。

解决方法就是：利用static声明内部类。

利用static声明内部类

如果一个内部类使用static声明，则此内部类就称为外部类，可以直接通过”外部类.内部类“进行访问

class Outer{        // 定义外部类
    private static String info = "hello world" ;    // 定义外部类的私有属性，必须是static修饰的才能被内部类使用，
　　//因为内部类被static修饰了。
    static class Inner{    // 使用static定义内部类为外部类
        public void print(){                // 定义内部类的方法
            System.out.println(info) ;        // 直接访问外部类的私有属性
        }
    };
    public void fun(){                        // 定义外部类的方法
        new Inner().print() ;                // 通过内部类的实例化对象调用方法
    }
};
public class InnerClassDemo03{
    public static void main(String args[]){
        new Outer.Inner().print() ;                    // 调用外部类的fun()方法，注意，这里Outer.Inner是一个整体，相当于一个类名。
　　　　//这里是实现一个内部类的实例化对象，看清楚是new Outer.Inner()，而不是new Outer().new Inner(),这里Outer.Inner相当于一个类名使用。

    }
};

1）使用static可以声明一个内部类，可以在类的外部调用。

2）但是，如果要想访问的外部类中的属性，则此属性必须是static访问权限的。

在外部访问内部类

一个内部类出来可以通过外部类访问，也可以在其他类中调用，

但是调用的格式：外部类.内部类  对象名=外部类实例.new  内部类（）；

class Outer{        // 定义外部类
    private String info = "hello world" ;    // 定义外部类的私有属性
    class Inner{    // 定义内部类
        public void print(){                // 定义内部类的方法
            System.out.println(info) ;        // 直接访问外部类的私有属性
        }
    };
    public void fun(){                        // 定义外部类的方法
        new Inner().print() ;                // 通过内部类的实例化对象调用方法
    }
};
public class InnerClassDemo04{
    public static void main(String args[]){
        Outer out = new Outer()    ;            // 外部类实例化对象
        Outer.Inner in = out.new Inner() ;    // 实例化内部类对象
        in.print() ;                        // 调用内部类的方法
    }
};

在方法中定义内部类

一个内部类可以在任何地方定义。下面看一下在方法中定义内部类。

class Outer{        // 定义外部类
    private String info = "hello world" ;    // 定义外部类的私有属性
    public void fun(final int temp){        // 定义外部类的方法，内部类要想使用方法中的参数，参数必须是final类型。
        class Inner{                        // 在方法中定义的内部类
            public void print(){                // 定义内部类的方法
                System.out.println("类中的属性：" + info) ;        // 直接访问外部类的私有属性
                System.out.println("方法中的参数：" + temp) ;
            }
        };
        new Inner().print() ;                // 通过内部类的实例化对象调用方法
    }
};
public class InnerClassDemo05{
    public static void main(String args[]){
        new Outer().fun(30) ;    // 调用外部类的方法
    }
};

总结

内部类在开发中非常有用处，而且是经常使用的，所以一定要熟悉其语法和优点。

在java开发中，会到处看到static修饰内部类的情况，一定要记住，使用static声明的内部类是外部类，

操作的时候要使用“内部类.外部类”的形式。