内部类

Posted 2020-10-06

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

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