内部类

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类作为Outer类的内部类存在，并且在外部类的fun()方法中直接实例化内部类的对象并调用print()方法。

class Outer{        //定义外部类
    private String info = "hello world!" ;        //定义外部类的私有属性
    public void fun(){        //定义外部类的方法        
        new Inner(this).print() ;        //通过内部类实例化对象调用内部方法
    }    
    public String getInfo(){
        return this.info ;
    }
}
class Inner{            //定义内部类
    private Outer out = null ;        //声明outer对象
    public Inner(Outer out){
        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()方法
    }
}

如果将内部类拿到外部之后，会发现代码增加了，而且复杂度也增加了，使用内部类的最大优点，可以方便的访问外部类的的私有属性。

但是，在上面的内部类中是无法在外部类直接调用的

 

二、使用static 声明内部类

　　如果一个内部类使用static关键字申明，则此内部类就成为外部类，可以通过外部类.内部类直接访问。但是想访问外部类总的属性，此属性必须是static访问权限的。

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

三、在外部访问内部类

一个内部类除了可以通过外部类访问也可以直接在其他类中调用，但是调用的格式：

· 外部类.内部类 内部类对象 = 外部类实例.new 内部类() ;

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

四、在方法中定义内部类

在方法中声明的内部类需要访问方法中的参数的时候，参数必须被final修饰的。

class Outer{        //定义外部类
    private String info = "hello world !" ;            //定义外部类的私有属性
    public void fun(final int temp){
        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) ;
    }
}