java内部类的用法

内部类共分４种：常规内部类、静态内部类、局部内部类、匿名内部类

１．常规内部类：常规内部类没有用static修饰且定义在在外部类类体中。
- 常规内部类中的方法可以直接使用外部类的实例变量和实例方法。
- 在常规内部类中可以直接用内部类创建对象

---

public class OuterClass {
    private int x = 100;
    // 创建内部类
    class InnerClass {
        public void innerMethod() {
            // 外部类中的实例变量可以直接访问
            System.out.println("外部类中的x =" + x);
            //外部类的方法可以直接调用
            outerMethod();
            System.out.println("x is" + MyOuter.this.x);
         }
    }
    public void outerMethod() {
        x++;
    }
    public void makeInner() {
        //在外部类方法中创建内部类实例
        MyInner in = new MyInner();
    }
    public static void main(String[] args) {
        MyOuter mo = new MyOuter();
        // 使用外部类构造方法创建mo对象
        MyOuter.MyInner inner = mo.new MyInner();       
        // 创建inner对象
        inner.innerMethod();
    }
}

2.静态内部类：用static修饰的常规内部类。
- 只能访问外部类的static成员，不能直接访问外部类的实例变量与实例方法，只有通过对象引用才能访问。

public class OuterClass {
    public static int x=100;
    public static class InnerClass{
        public void innerMethod(){
            //只能访问外部static属性
            System.out.println("x="+x);
        }
    }
    public static void main(String[] args) {
        MyOuter.InnerClass si=new MyOuter.InnerClass();
        //静态内部类不通过外部实例就可以创建对象
        si.innerMethod();
   }    
}

3.局部内部类：在方法体或语句块（包括方法、构造方法、局部块或静态初始化块）内部定义的类成为局部内部类。

• 局部内部类不能加任何访问修饰符，因为它只对局部块有效。
• 局部内部类只在方法体中有效，在定义的方法体外不能创建局部内部类的对象

public class JuBu{
    private int x=5,y=7;
    public Object makeInner(int localVar){
            final int finalLocalVar=localVar;
            //创建内部类，该类只在makeInner（）方法有效。
            //在方法体外部不能创建MyInner类的对象
            class MyInner{
                int y=4;
                public String toString(){
                    return "x:"+x+"\ny"+"this.y="+this.y;
                }
            }
            return new MyInner();
    }
    public static void main(String[] args) {
        //创建Jubu对象obj，并调用它的makeInner（）方法
        Object obj=new JuBu().makeInner(47);    
        //该方法返回一个MyInner类型的的对象obj，然后调用其同toString方法。
        System.out.println(obj);
    }
}

4.匿名内部类：定义类的同时就创建一个类，以这种方法定义的没有名字的类成为匿名内部类。

public class NiMing {
private int x=5;
    public Object makeInner(int y){
            final int finalY=y;
            return new Object(){
                //使用匿名内部类
                public String toString(){
                    return "OuterX="+x+"\nfinalY="+finalY;
                }
            };
    }
    public static void main(String args[]){
        Object obj=new NiMing().makeInner(47);
        System.out.println(obj.toString());
    }
}

５. 一个文档写两个Class，这种写法是允许的，但它不是内部类，它只是普通类，只是一个文档只能有一个public修饰的Class

public class OutClass{
    int a;
    public static void main(String args[]){
        System.out.println("a="+a);
    }
}
class InnerClass{
    int b;
    public void innerMather(){
        System.out.println("b="+b);
    }
}