内部类

内部类可以直接访问其外部类的所有变量和方法,内部类和外部类的区别是:外部类只可以声明为pulibc和空,而内部类可以声明为private,protected,及static属性.
内部类的方法可以直接访问外部类的变量.其实,在内部类中保存了一个对外部类对象的引用;当内部类的成员方法中访问某一个变量时,首先在该方法及内部类中查找该变量;如果没有定义过这个变量,访问就会被传递给内部类中保存的那个外部类对象的引用,通过那个外部类对象的引用去访问外部类类中的这个变量,在内部类中调用方法也是一样的道理.
内部类的种类:
一.在一个类中直接定义的内部类
class TheOuter{
...
 classInner{
 .....
 }
....
}
二.在一个方法中定义个内部类
class TheOuter{
...
public void method(){
...
class Inner{
....
}
...
}
.....
}
三.匿名内部类(定义在方法的参数内)
public class AnonymousInnerClass{
...
method(
new InnerClass(){
...
}
)
...
}
例子:
public class A{
public void init(){
addMouseListener(new MouseAdapter(){
public void mousePressed(MouseEvent e){
showStatis("oh,MousePressed!");
}
});
}
}
内部类和外部类访问关系
例一.
public class Outer3{
        int outer_x=100;
        class InnerOne{
                public int y=10;
                private int z=9;
                int m=5;
                public void display2(){
                        System.out.println("displayouter_x:"+outer_x);
                }
                private void display(){
                        System.out.println("displayouter_x:"+outer_x);
                }
        }
        class InnerTwo{
                InnerOne innerx=new InnerOne();
                public void show(){
                        //不可直接访问Inner的y成员
                        //System.out.println(y);
                        //不可直接访问Inner的任何成员和方法
                        //System.out.println(InnerOne.y);display();
                        innerx.display();
                        innerx.display2();
                        System.out.println(innerx.y);
                }
        }
        void test(){
                InnerOne inner=new InnerOne();
                inner.display();
                inner.dispaly2();
                System.out.println(inner.y);
                InnerTwo innerTwo=new InnerTwo();
                innerTwo.show();
        }
        public static void main(String args[]){
                Outer3 outer=new Outer3();
                outer.test();
        }
}
例二.
 public class OuterReference{
        public static void main(String args[]){
                OuterY outer=new OuterY();
                OuterY.Inner inner=outer.getInner();
                inner.print();
        }
}
class OuterY{
        private int index=100;
        class Inner{
                private int index=50;
                public void print(){
                        int index=30;
                        System.out.pritnln(index);//30
                        System.out.pritnln(this.index);//50
                        System.out.pritnln(OuterY.this.index);//100

                }
        }
        Inner getInner(){
                return new Inner();
        }
}
例三.
public class Outer4{
        public static void main(String args[]){
                Outerclass outer=new Iuterclass();
                Outclass.innerclass inner=outer.new innerclass();
                inner.print();
        }
}
class Outerclass{
        int x;
        int y;
        class innerclass{
                public void print(){
                        x=10;
                        System.out.print("x="+x);
                }
        }
}
内部类可以被声明为static属性,该内部列即为静态内部类,普通类是不允许被声明为static的,其实,静态内部类相当于外部类的一个静态成员,,static的内部类不能使用外部类的非static成员.
public class StaticInnerClass{
        public static void main(String args[]){
                Outer1.Inner1 inner=new Outer1.Inner1();
                inner.m3();
        }
}
class Outer1{
        private int a1=5;
        private static int a2=10;
        private void m1(){
                System.out.println("m1() method!");
        }
        private static void m2(){
                System.out.println("m2() method!");
        }
        static class Inner1{
                public void m3(){
                        System.out.println(a2);
                        m2();
                }
        }
}