Java内部类应用实践（修正版）

作者:fbysss
msn:[email protected] 
blog:blog.csdn.net/fbysss
声明：本文由fbysss原创，转载请注明出处
关键字：Java 内部类平日里，Java内部类很少在项目中使用，看了《幕后英雄的用武之地——浅谈Java内部类的四个应用场景》，有一些启发。但是该文说实话太长，也有点乱，而且代码走不通，粗看了前三种应用，做了几个实例，先总结一下，第四种日后补上。

第一种应用，简而言之可以类比c语言里面的struct，方便，而且还可以对外部隐藏（通过private）。

 

说明：我习惯使用Container来命名inner class外部的class，以区别该Java文件以外的class，感觉这样更贴切。

1. package com.sss.exam.inner;
2. /**
3.  * <p>标题: OutterApp1.java</p>
4.  * <p>功能描述:内部类应用场景1：
5.  * 相当于delphi的记录类型，或者c的结构体 
6.  * 
7.  * <p>版权: Copyright (c) 2007</p>
8.  * <p>公司: </p>
9.  * @author fbysss 
10.  * @version 1.0
12.  */
14. public class Container1 {
15.     private class PrivateParams{//私有是针对外部其他类的访问是私有的。即外部的其他类不能访问
16.         public int id ;
17.         public String name;
18.     }
19.     
20.     public class PublicParams{
21.         public int id ;
22.         public String name;
23.     }   
24.     /*本方法可以访问私有内部类
25.      * */
26.     public void testParams(){
27.         PrivateParams params = new PrivateParams();
28.         params.id = 1;
29.         params.name = "sss";
30.     }
31.     /**
32.      * @param args
33.      */
34.     public static void main(String[] args) {
35.         Container1 out = new Container1();
36.         //Container1可以访问public内部类和private内部类
37.         PublicParams pp = out.new PublicParams();
38.         pp.id = 2;
39.         pp.name = "sss2";
40.         
41.         PrivateParams params = out.new PrivateParams();
42.         params.id = 3;
43.         pp.name = "sss3";
45.     }
47. }

其他类访问：

1. public class JustTest {
2.     public static void main(String[] args) {
3.         Container1 out = new Container1();
4.         //Container1可以访问public内部类和private内部类
5.         PublicParams pp = out.new PublicParams();
6.         //compile error .不能访问私有内部类PrivateParams params = out.new PrivateParams();
7.     }
8. }

第二种和第三种应用，我认为差别不大，可以理解为一种情况，不过是解决不同的问题罢了。

 

1. package com.sss.exam.inner;
2. /**
3.  * <p>标题: Container2.java</p>
4.  * <p>功能描述: <br>
5.  *
6.  * </p>
7.  * <p>版权: Copyright (c) 2007</p>
8.  * <p>公司: </p>
9.  * @author fbysss 
10.  * @version 1.0
11.  */
12. /***
13.  * 同一个类里面定义非public的类，不能加final abstract 之外的modifier
14.  * 其modifier 值为0，不在Modifier的定义里面。有人称之为friendly修饰符
15. *这里的User跟单独写一个User类的区别仅仅在于modifier.编译出来的class都是单独存在的。
16.  */
17. class User{ 
18.     int id;
19.     String name;
20. }
22. public class Container2 {
23.     private User user = null;
24.     //一个对象是可以这样的，解决了try catch的问题。
25.     //但是如果是一个String,则不行，问题就在Java的传值和传引用的问题。String相当于就是传值的。
26.     /**
27.      * @param args
28.      */
29.     public static void main(String[] args) {
30.         /*背景：catch和finally都相同，只是try部分不同
31.          * 传统方法：每次都需要写try,catch,finally
32.          * 
33.          */
34.         /*
35.         String user = null;
36.         try{
37.             user = "fbysss";
38.         }catch(Exception e){
39.             user = "error.";
40.         }finally{
41.             user += "'s work finished.";
42.         }*/
44.         Container2A c2a = new Container2A();
45.         c2a.newMethod();
46.         
48.     }
49.     //使用了内部类的调用方法：
50.     public void newMethod(){
51.         Container2Common c2c = new Container2Common();
52.         c2c.execute(new MyMethod(){//BaseMyMethod(){ 这里不必如此，匿名内部类可以通过这种方法直接实现接口
53.             public User doMyMethod(){//必须要有返回值，否则通用处理方法得不到user
54.                 //error.无法访问user变量，必须声明为成员变量，user = "fbysss";               
55.                 user = new User();
56.                 user.name = "fbysss";
57.                 System.out.println(user.name);
58.                 return user;
59.                 
60.             }
61.         });
62.         System.out.println("old user is:"+user.name);
63.     }
65. }

公共处理类：

1. public class Container2Common {
2.     public void execute(MyMethod mm){
3.         User user = null;
4.         try{
5.             //通用接口方法，但是具体代码不一样
6.             user = mm.doMyMethod();
7.         }catch(Exception e){
8.             user.name = "error.";
9.         }finally{
10.             user.name += "'s work finished.";
11.             System.out.println(user.name);
12.         }
13.     }
14. }

个性方法接口：

1. public interface MyMethod {
2.     public User doMyMethod();
3. }

上面实际上是一个Java匿名内部类的编写过程。人们常说的Java 回调机制，一般也是通过匿名内部类来实现的。

相关文章： http://blog.csdn.net/hivon/archive/2006/02/22/606312.aspx