内部类

1 内部类的概述

• 将一个类定义在另一个类里面，对里面那个类就称为内部类。

 

• 内部类的访问特点：
  • ①内部类可以直接访问外部类中的成员，包括私有成员。
  • ②外部类要访问内部类中的成员必须建立内部类的对象。　　

 

• 示例：

package java010;/** * 2017/9/12 * 说明： */class Outer{//外部类    private int num = 10;    class Inner{//内部类        public void show(){            System.out.print("num:"+num);        }    }    public void method(){        Inner inner = new Inner();        inner.show();    }}public class Test {    public static void main(String[] args) {        Outer o = new Outer();        o.method();    }}

• 内部类的应用：
  • 一般用于类的设计。分析事物的时候，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时这个还有的事物就被定义为内部类。　　

 

2 内部类的修饰符

• 内部类的访问修饰符是public的时候

package java010;/** * 2017/9/12 * 说明： */class Outer{//外部类    private int num = 10;    public class Inner{//内部类        public void show(){            System.out.print("num:"+num);        }    }    public void method(){        Inner inner = new Inner();        inner.show();    }}public class Test {    public static void main(String[] args) {        //直接访问外部类中内部类的成员        Outer.Inner oi = new Outer().new Inner();        oi.show();    }}

• • 可能大家会觉的奇怪，在这边我说说自己的理解。
  • ①绝对不肯能通过下面的格式就能直接访问外部类中的内部类的成员。　　　

 Inner inner = new Inner(); inner.show();

• • • 为什么？如果我类的结构是这样的。　　　　

class Outer{//外部类    private int num = 10;    public class Inner{//内部类        public void show(){            System.out.print("num:"+num);        }    }    public void method(){        Inner inner = new Inner();        inner.show();    }}class Outer2{    public class Inner{    }}

• • • 如果采用这种方式，编译器不会知道到底实例化的是那个内部类对象吧。　　　　　
  • ②从①中，我们应该可以猜出类型应该是这样的Outer.Inner。但是如果实例化内部类的对象呢？我们知道内部类是属于外部类的一个成员，所以，我们首先必须实例化外部类，得到外部类的对象，这样才可以访问成员，然后再实例化内部类，这样就能才能访问内部类对象的方法了，代码如下所示。　　

 //直接访问外部类中内部类的成员  Outer.Inner oi = new Outer().new Inner();  oi.show();

 

• 当内部类的访问修饰符是默认的，和上面的是一样的。

package java010;/** * 2017/9/12 * 说明： */class Outer{//外部类    private int num = 10;    class Inner{//内部类        public void show(){            System.out.print("num:"+num);        }    }    public void method(){        Inner inner = new Inner();        inner.show();    }}public class Test {    public static void main(String[] args) {        //直接访问外部类中内部类的成员        Outer.Inner oi = new Outer().new Inner();        oi.show();    }}

• 当内部类的访问修饰符是protected时，和上面的一样。

package java010;/** * 2017/9/12 * 说明： */class Outer{//外部类    private int num = 10;    protected class Inner{//内部类        public void show(){            System.out.print("num:"+num);        }    }    public void method(){        Inner inner = new Inner();        inner.show();    }}public class Test {    public static void main(String[] args) {        //直接访问外部类中内部类的成员        Outer.Inner oi = new Outer().new Inner();        oi.show();    }}

• 当内部类的访问修饰符是static，和上面不一样了，相等于一个外部类。

package java010;/** * 2017/9/12 * 说明： */class Outer{//外部类    private static int num = 10;    static class Inner{//内部类        public void show(){            System.out.print("num:"+num);        }    }    public void method(){        Inner inner = new Inner();        inner.show();    }}public class Test {    public static void main(String[] args) {        //直接访问外部类中内部类的成员        Outer.Inner oi = new Outer.Inner();        oi.show();    }}

• 如果内部类的访问修饰符是static，而成员的访问修饰符也是static。

package java010;/** * 2017/9/12 * 说明： */class Outer{//外部类    private static int num = 10;    static class Inner{//内部类        public static void show(){            System.out.print("num:"+num);        }    }    public void method(){        Inner inner = new Inner();        inner.show();    }}public class Test {    public static void main(String[] args) {       Outer.Inner.show();    }}

 

• 注意：当内部类有静态成员的时候，内部类的访问修饰符必须为static。因为，如果内部类的成员是静态的，那么会随着外部类一起加载进来，所以内部类的访问修饰符不是static，不是自相矛盾了吗？

 

3 内部类的思考题

package java010;/** * 2017/9/12 * 说明： */class Outer{//外部类    int num =3;     class Inner{//内部类         int num = 4;        public  void show(){            int num = 5;            System.out.print(Outer.this.num +" "+this.num+" "+num);        }    }    public void method(){        Inner inner = new Inner();        inner.show();    }}public class Test {    public static void main(String[] args) {        new Outer().method();    }}

• 为什么内部类可以直接访问外部了的成员？
• 答：因为内部类持有外部类的引用，外部类名.this。

 

^{4 局部内部类}

• 内部类可以放在局部位置上。

 

• 示例

package java010;/** * 2017/9/12 * 说明： */class Outer{//外部类    int num =3;    public void method(){        class Inner{            public void show(){                System.out.print(Outer.this.num);            }        }        Inner i = new Inner();        i.show();    }}public class Test {    public static void main(String[] args) {        new Outer().method();    }}

 

• 当内部类访问局部变量的时候，需要将变量变为常量。

package java010;/** * 2017/9/12 * 说明： */class Outer{//外部类    int num =3;    public void method(){       final int x = 9;        class Inner{            public void show(){                System.out.print(x);            }        }        Inner i = new Inner();        i.show();    }}public class Test {    public static void main(String[] args) {        new Outer().method();    }}

 

5 匿名内部类

5.1 匿名内部类的使用

• 匿名内部类就是内部类的简单形式。

 

• 匿名内部类的前提是：内部类必须继承一个外部类或者实现一个外部接口。

 

• 示例：内部类没有继承一个外部类或者实现一个外部接口的

class Outer{//外部类    int num = 3 ;    class Inner{        public void show(){            System.out.print("show："+num);        }    }    public void method(){        new Inner().show();    }}

• 示例：内部类继承了一个抽象类

abstract  class  Demo{    public abstract  void show();}class Outer{//外部类    int num = 3 ;    class Inner extends Demo{        public void show(){            System.out.print("show："+num);        }    }    public void method(){        new Inner().show();    }}

abstract  class  Demo{    public abstract  void show();}class Outer{//外部类    int num = 3 ;    public void method(){        new Demo(){            @Override            public void show() {                System.out.print(num);            }        }.show();    }}

 

5.2 匿名内部类的应用

• 当函数参数时接口类型时，并且接口中的方法不超过三个，可以用匿名内部类作为实际参数进行传递。