黑马程序员_内部类

------- android培训、 java培训、期待与您交流！ ----------

什么是内部类？

    内部类（Inner Classes）就是讲一个类定义在另一个类里面，对里面的那个类就称为内部类也称为内置类、嵌套类。A类可以直接访问B类成员，B类访问A类的成员需要创建对象。针对这种情况，java提出了内部类：

class Outer

{

    private int num = 10;

     class Inner

    {

        public void show()

        {

            System.out.println(num);

        }

    }

     public void method()

    {

        Inner i = new Inner();

        i.show();

    }

}

 

class OuterDemo

{

    public static void main(String[] args)

    {

        //直接使用,编译报错，找不到Inner类。为什么呢？因为Inner类定义在Outer类的内部。不能直接使用。

        //Inner i = new Inner();

        //i.show();

         //那么，该怎么使用呢？

        //外部类名.内部类名 变量 = 外部类对象.内部类对象;

        Outer.Inner oi = new Outer().new Inner();

        oi.show();

    }

}

内部类定义在成员位置上，称为成员内部类。可以被private static成员修饰符修饰，被static修饰的内部类只能访问外部类中的静态成员。看以下几个例子：

public class Outer {

    private int size;

    public class Inner {

        public void dostuff() {

            size++;

        }

    }

    public void testTheInner() {

        Inner in = new Inner();

        in.dostuff();

    }

}

成员式内部类如同外部类的一个普通成员。


成员式内部类的访问


内部类的对象以属性的方式记录其所依赖的外层类对象的引用，因而可以找到该外层类对象并访问其成员 。 该属性是系统自动为非static的内部类添加的，名称约定为“外层类名.this”。


（1）在另一个外部类中使用非静态内部类中定义的方法时，要先创建外部类的对象，再创建与外部类相关的内部类的对象，再调用内部类的方法，如下所示：

class Outer {

    private int size;

    class Inner {

        public void dostuff() {

            size++;

        }

    }

}

class TestInner {

    public static void main(String[] args) {

        Outer outer = new Outer();

        Outer.Inner inner = outer.new Inner();

        inner.dostuff();

    }

}

（2）成员内部类被静态修饰：


对于成员变量被static修饰，如果想在测试类使用：


    外部类名.内部类名 变量 = new 外部类名.内部类构造方法;

  class Outer

{

    private int num = 10;

    private static int num2 = 10;

 

    static class Inner

    {

        public void show()

        {

            System.out.println(num2);

        }

 

        public static void show2()

        {

            System.out.println(num2);

        }

    }

}

 

class OuterDemo3

{

    public static void main(String[] args)

    {

        //Outer.Inner oi = new Outer().new Inner();

        //oi.show();

 

        Outer.Inner oi = new Outer.Inner();  //Outer起到限定的作用

        oi.show();

        oi.show2();

       //如果静态内部类的方法也是静态的。就使用下面这种方式即可。

        //Outer.Inner.show2();

    }

}

内部类放在局部位置上的使用：

class Outer

{

    private int num = 10;

 

    public void method()

    {

        class Inner

        {

            public void show()

            {

                System.out.println(num);

            }

        }

        //创建对象使用

        Inner i = new Inner();

        i.show();

    }

}

 

class OuterDemo

{

    public static void main(String[] args)

    {

        //如何使用呢?

        Outer o = new Outer();

        o.method();

    }

}

匿名内部类


没有名字的内部类。匿名内部类的前提是存在一个其他类或者接口。其格式：


       new 其他类或者接口名()


    {


        重写方法


        (也可以自定义方法。)


    };


     这是一个实现了接口的匿名对象。示例如下：

  interface Inter

{

    public abstract void show();

    public abstract void show2();

}

 class Outer

{

    public void method()

    {

              Inter i = new Inter()  //多态

        {

            public void show()

            {

                System.out.println("show");

            }

                    public void show2()

            {

                System.out.println("show2");

            }

        };//注意：匿名内部类是在一个语句里面，所以后面需要加“;”。

         i.show();

        i.show2();

    }

}

 class OuterDemo

{

    public static void main(String[] args)

    {

        Outer o = new Outer();

        o.method();

    }

}

内部类规则总结：

内部类可以直接访问外部类中的成员，包括私有成员；

    而外部类要访问内部类中的成员必须要建立内部类的对象。