Java中四种内部类

一、内部类的访问特点

* a：内部类可以直接访问外部类的成员，包括私有

* b：外部类要访问内部类的成员，必须创建对象

* c：创建对象

//外部类名.内部类名 = 外部类对象.内部类对象
Outer.Inner oi = new Outer().new Inner(); //创建内部类对象

二、成员内部类

使用示例：

     Java Code  
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Demo1_InnerClass {
     public static void main( String [] args) {
     //外部类名.内部类名 = 外部类对象.内部类对象
        Outer.Inner oi = new Outer(). new Inner(); //创建内部类对象
        oi.method();

    }
}

class Outer {
     private int num = 10 ;
     class Inner {
         public void method() {
            System.out.println(num);
        }
    }
}

成员内部类私有使用，需要提供公共的访问方式：

     Java Code  
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Demo2_InnerClass {
     public static void main( String [] args) {
        Outer o = new Outer();
        o.print();
    }
}

class Outer {
     private int num = 10 ;
     private class Inner {
         public void method() {
            System.out.println(num);
        }
    }

     public void print() {
        Inner i = new Inner();
        i.method();
    }
}

三、静态内部类

使用示例：

     Java Code  
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class Demo1_InnerClass {
     public static void main( String [] args) {
         //外部类名.内部类名对象名 = 外部类名.内部类对象;
        Outer.Inner oi = new Outer.Inner();   //实际上是  Outer.new Inner()
        oi.method();
        Outer.Inner2.print();
    }
}

class Outer {
     static class Inner {
         public void method() {
            System.out.println( "method" );
        }
    }
     static class Inner2 {
         public static void print() {
            System.out.println( "print" );
        }
    }
}

静态内部类面试题：

要求：使用已知的变量，在控制台输出30，20，10。

     Java Code  
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Test1_InnerClass {
     public static void main( String [] args) {
        Outer.Inner oi = new Outer(). new Inner();
        oi.show();
    }
}
//内部类之所以能获取到外部类的成员,是因为他能获取到外部类的引用外部类名.this
class Outer {
     public int num = 10 ;
     class Inner {
         public int num = 20 ;
         public void show() {
             int num = 30 ;
            System.out.println(num);
            System.out.println( this .num);
            System.out.println(Outer. this .num);
        }
    }
}

四、局部内部类

特点：

* 局部内部类在访问他所在方法中的局部变量必须用final修饰,因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用

*局部内部类,只能在其所在的方法中访问

     Java Code  
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//局部内部类
class Outer {
     public void method() {
         final int num = 10 ;
         class Inner {
             public void print() {
                System.out.println(num);
            }
        }
        Inner i = new Inner();
        i.print();
    }
     /*public void run() {
        Inner i = new Inner();              //局部内部类,只能在其所在的方法中访问
        i.print();
    }*/
}

五、匿名内部类

1，匿名内部类的格式和理解

* A:匿名内部类
        * 就是内部类的简化写法。
* B:前提：存在一个类或者接口
        * 这里的类可以是具体类也可以是抽象类。
* C:格式：
        *
        new 类名或者接口名(){
                重写方法;
        }
* D:本质是什么呢?
        * 是一个继承了该类或者实现了该接口的子类匿名对象。

2，匿名内部类重写多个方法调用

     Java Code  
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

class Demo2_NoNameInnerClass {
     public static void main( String [] args) {
        Outer o = new Outer();
        o.method();
    }
}

interface Inter {
     public void show1();
     public void show2();
}
//匿名内部类只针对重写一个方法时候使用
class Outer {
     public void method() {
         /*new Inter(){
            public void show1() {
                System.out.println("show1");
            }

            public void show2() {
                System.out.println("show2");
            }
        }.show1();

        new Inter(){
            public void show1() {
                System.out.println("show1");
            }

            public void show2() {
                System.out.println("show2");
            }
        }.show2();*/

        Inter i = new Inter(){
             public void show1() {
                System.out.println( "show1" );
            }

             public void show2() {
                System.out.println( "show2" );
            }

             /*public void show3() {
                System.out.println("show3");
            }*/
        };

        i.show1();
        i.show2();
         //i.show3();                        //匿名内部类是不能向下转型的,因为没有子类类名
    }
}