Java内部类

1.内部类

Java内部类其实在J2EE编程中使用较少，不过在窗口应用编程中特别常见，主要用来事件的处理。其实，做非GUI编程，内部类完全可以不用。

 

内部类的声明、访问控制等于外部类有所不同，要灵活使用内部类来编写程序，还是有相当难度的，Java发明了这种难懂的玩意儿，在其他语言中是没有的，但是在Java中，内部类也相当的重要，尤其做GUI开发时候，事件的响应处理全靠内部类了。

 

内部类按照其所在位置不同，可分为以下几种：

1. （普通的）内部类（最常见的内部类，内部类的定义与类成员平级，）
2. 方法内部类
3. 匿名类
4. 静态内部类
5. 接口内部类

•  含义：在一个类的内部可以定义一个类，此类叫内部类

 

•  内部类对象创建过程中一定要使用“主类对象.new 内部类的构造方法()”
•  内部类可以使用主类中方法，属性
• 内部类可以使用private修饰符

 

 /** 
* 内部类创建与初始化 
*/ 
public class Outer { 
        private int i = 10; 
        private int y = 8; 

        Outer() { 
                System.out.println("调用Outer构造方法：outer"); 
        } 

        public void sayMsg() { 
                System.out.println("Outer class!"); 
        } 

        class Inner { 
                int i = 1000; 

                Inner() { 
                        System.out.println("调用Inner构造方法：inner"); 
                } 

                void innerMsg() { 
                        System.out.println(">>>>>Inner class!"); 
                        sayMsg(); 
                        //访问内部类自己的成员i，也可以写成 this.i++ 
                        this.i++; 
                        //访问外部类的成员 i和y 
                        Outer.this.i++; 
                        y--; 
                } 

                int getI() { 
                        return i; 
                } 
        } 

        public void test() { 
                Inner in = new Inner(); 
                in.innerMsg(); 
        } 

        public int getI() { 
                return i; 
        } 

        public void setI(int i) { 
                this.i = i; 
        } 
} 

class Test1 { 
        public static void main(String[] args) { 
                Outer outer = new Outer(); 
                outer.test(); 
                System.out.println(outer.getI()); 
                System.out.println("-------1--------"); 

                Outer.Inner iner = outer.new Inner(); 
                iner.innerMsg(); 
                System.out.println(iner.getI()); 
                System.out.println("-------2--------"); 

                System.out.println(outer.getI()); 
        } 
}

 运行结果：

调用Outer构造方法：outer 
调用Inner构造方法：inner 
>>>>>Inner class! 
Outer class! 
11 
-------1-------- 
调用Inner构造方法：inner 
>>>>>Inner class! 
Outer class! 
1001 
-------2-------- 
12 

 

2.匿名内部类

语法: 

 

 1 public void m01(类型名 obj) {
 2 }
 3 
 4 //如何使用
 5 1.类型名 obj = new 类型构造方法();
 6 2.m01(obj);
 7 
 8 //另一种方式使用
 9 m01(new 类型构造方法() { //匿名内部类
10 
11 });

 

举例：

 /** 
* 匿名类. 
*/ 
public class Test3 { 
        public Foo f = new Foo() { 
                public void say() { 
                        System.out.println("O(∩_∩)O哈哈~!"); 
                } 
        }; 

        public Foo test() { 
                return new Foo() { 
                        public void say() { 
                                System.out.println("say foo!"); 
                        } 
                }; 
        } 

        public static void main(String[] args) { 
                Test3 t = new Test3(); 
                t.f.say(); 
                t.test().say(); 
        } 
} 

interface Foo { 
        void say(); 
}

3.接口可以当作匿名类来使用

 

 /** 
* 内部类实现接口 
*/ 
public class Test2 { 
        public static void main(String[] args) { 
                Outer o = new Outer(); 
                Outer.Bar b = o.genBar(); 
                b.readme(); 
        } 
} 

class Outer { 

        protected class Foo { 
                protected void say() { 
                        System.out.println("say foo!"); 
                } 

                private void test() { 
                        System.out.println("----test------"); 
                } 
        } 

        protected class Bar { 
                protected void readme() { 
                        System.out.println("say bar!"); 
                        new Foo().test(); 
                } 
        } 

        public Foo genFoo() { 
                return new Foo(); 
        } 

        public Bar genBar() { 
                return new Bar(); 
        } 
}

4.静态内部类

 

静态内部类是static class型的内部类，这种内部类特点是：它不能访问外部类的非静态成员。要创建静态内部类对象时候，也不需要外部类对象了，直接可以：

new 外部类名.内部类构造方法

 

•  内部类可以使用static修饰符

• 内部类其实也是相当于一个语句块，和方法类似
• 如果内部类使用static修饰, 则此内部类就是一个静态代码块
• 主类中非静态的方法就不能在静态内部类中使用
• 静态内部类对象的初始化“new 主类名.内部类构造方法()”

来创建，给个例子：

 1 /** 
 2 * 静态内部类 
 3 */ 
 4 public class Outer { 
 5         public static int i =500; 
 6         protected static class Inner { 
 7                 int i =100; 
 8                 String name; 
 9 
10                 Inner(String name) { 
11                         this.name = name; 
12                 } 
13 
14                 void sayHello() { 
15                         System.out.println("Hello " + name); 
16                         Outer.i++; 
17                 } 
18         } 
19 
20         public Inner genInner(String name) { 
21                 return new Inner(name); 
22         } 
23 } 
24 
25 class Test { 
26         public static void main(String[] args) { 
27                 Outer.Inner in1 = new Outer.Inner("1111"); 
28                 in1.sayHello(); 
29                 System.out.println(Outer.i); 
30 
31                 Outer.Inner in2 = new Outer().genInner("2222"); 
32                 in2.sayHello(); 
33                 System.out.println(Outer.i); 
34         } 
35 }

运行结果：

Hello 1111 
501 
Hello 2222 
502