分类

内部类

JAVA学习网 2017-09-13 15:10:02

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 匿名内部类的应用

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

 

阅读(798) 评论(0)