内部类

1.内部类
定义：一个类定义在另外一个类的内部，这个类叫做内部类
何时会用到内部类：内部类的唯一好处是方便的访问外部类中的私有属性，从而减少代码。

1. public class First {
2. //Contens为内部类，内部了了解外部类，并能与之通信
3. public class Contents{
4.     public void f(){
5.     System.out.println(“In Class First’s inner Class Contents method f()”);
6.     }
7. }
8.  }

2.链接到外围类
创建了内部类对象时，它会与创造它的外围类对象有某种联系，于是能访问外围类的所有成员，不需要特殊条件

1. public class First {
2. private String str;
3. public class Contents{
4.          public void getStr(){
5.         /*在内部类Contents中，可以使用外围类First的字段str
6.          *用外围类创建内部类对象时，此内部类对象会秘密捕获一个指向外围类的引用，于是可以通过这个引用来访问外部类的成员
7.          *通常，这些都是编译器来处理，我们看不到也无需关心
8.           *正因为如此，我们创建内部类对象时，必须与外围类对象相关联，要不然将没有意义
9.          */
10.         System.out.println(“First.str=”+str);
11.          }
12.     }
13. }

3、使用关键字.this与.new
内部类中得到外部类对象的引用，可以使用.this关键字，注意与new的区别

1. public class Test2{
2.  private int num ;
3. public Test2(){
4. }
5. public Test2(int num){
6.     this.num = num;
7. }
8. private class Inner{
9.     public Test2 getTest2(){
10.         return Test2.this;
11.     }
12.     public Test2 newTest2(){
13.         return new Test2();
14.     }
15. }
16. public static void main(String [] args){
17.     Test2 test = new Test2(5);
18.     Test2.Inner inner = test.new Inner();
19.     Test2 test2 = inner.getTest2();
20.     Test2 test3 = inner.newTest2();
21.     System.out.println(test2.num);
22.     System.out.println(test3.num);
23. }
    输出结果为5  0
    使用.this后，得到创建该内部类时使用的外部类对象的引用，new则是创建了一个新的引用
    .new关键字
    如果想直接创建一个内部类对象，而不是通过外部类对象的方法得到，可以使用.new关键字，形式如：OutClass.InnerClass obj = outClassInstance.new InnerClass();必须是外围类对象.new，而不能是外围类.new

1. public class First {
2. public class Contents{
3.     public void f(){
4.         System.out.println(“In Class First’s inner Class Contents method f()”);
5.     }
6.     public void getStr(){
7.         System.out.println(“First.str=”+str);
8.     }
9. }
10. public static void main(String [] args){
11.     First first = new First();
12.     //必须通过外围类First的对象first来创建一个内部类的对象
    //而且需要注意的是，在创建外围类对象之前，不可能创建内部类的对象(嵌套类除外)。
13.     First.Contents contents = first.new Contents();
14.     contents.f();
15. }
16.     }

4、内部类和向上造型
将内部类向上转型为基本类，尤其是接口时，内部类就有了用武之地

1.  public interface Shape {
2. public void paint();
3.     }
4.     public class Painter {
5.        private class InnerShape implements Shape{
6.     public void paint(){
7.         System.out.println(“painter paint() method”);
8.     }
9. }
10. public Shape getShape(){
11.     return new InnerShape();
12. }
13.     public static void main(String []args){
14.     Painter painter = new Painter();
15.     Shape shape = painter. getShape();
16.     shape.paint();
17. }
18.     }
    此时，内部类是private的，可以它的外围类Painter以外，没人能访问。
    这样,private内部类给累的设计者提供了一种途径，通过这种方式可以完全阻止任何依赖于类型的编码，并完全隐藏实现的细节。

    5、方法内的类
    可以在方法内创建一个类。

    Java代码  

    1. public void test(){
    2. ass Inner{
    3.  public void method(){
    4. ystem.out.println(“在方法内创建的类”);
    5.  }
    7. }

    值得注意的是：方法内创建的类，不能加访问修饰符。
    另外，方法内部的类也不是在调用方法时才会创建的，它们一样也被编译了(怎么知道的？后面会有讲解)。

    6、匿名内部类

    Java代码  

    1.   public class Painter {
    2. ublic Shape getShape(){
    3. return new Shape(){
    4.     public void paint(){
    5.         System.out.println(“painter paint() method”);
    6.     }
    7. };
    9.       public static void main(String [] args){
    10.             Painter painter = new Painter();
    11.             Shape shape = painter.getShape();
    12.             shape.paint();
    13.       }
    14.   }
    15.   public interface Shape {
    16. ublic void paint();
    17.   }

    注意，匿名内部类后面的分号不可缺少！
    匿名类，顾名思义，就是没有名称。
    getShape（）方法里，就使用了匿名内部类。
    看上去很奇怪，不符合传统的写法？
    第一眼看上去确实是这样的。

    这样写，意思是创建了一个实现了Shape的匿名类的对象。
    匿名类可以创建，接口，抽象类，与普通类的对象。创建接口时，必须实现接口中所有方法。

    这是无参的，如果需要参数呢？
    可以直接传。

    Java代码  

    1.    public class B {
    2. public A getA(int num){
    3.     return new A(num){
    5.     };
    6. }
    7.    }
    8.    public class A {
    9. private int num;
    10. public A(int num){
    11.     this.num = num;
    12. }
    13. public A(){
    15. }
    16.    }

    Ok，在这个例子中，可以为A的构造方法传入一个参数。在匿名内部类中，并没有使用到这个参数。
    如果使用到了这个参数，那么这个参数就必须是final的。

    Java代码  

    1.    public class B {
    2. public A getA(final int num){
    3.     return new A(num){
    4.        public int getNum(){
    5.                      return num;
    6.                   }
    7.     };
    8. }
    9.    }
    10.    public class A {
    11. private int num;
    12. public A(int num){
    13.     this.num = num;
    14. }
    15. public A(){
    17. }
    18.    }

    如果不是final的，编译器就会提示出错。
    另外，还可以在匿名内部类里定义属性
    由于类是匿名的，自然没有构造器，如果想模仿构造器，可以采用实例初始化({})

    Java代码  

    1.    public A getA(){
    2. return new A(){
    3.     int num = 0;
    4.     String str;
    5.     {
    6.         str = “javaeye”;
    7.         System.out.println(“hello robbin”);
    8.     }
    9. };
    10.    }

    匿名内部类通过实例初始化，可以达到类似构造器的效果~

    另外可以通过匿名内部类来改造工厂方法。

    Java代码  

    1.   public interface Service {
    2. public void method1();
    3.   }
    4.   public interface ServiceFactory {
    5. Service getService();
    6.   }
    7.   public class Implemention1 implements Service{
    8. public void method1(){
    9.     System.out.println(“In Implemention1 method method1()”);
    10. }
    12. public static ServiceFactory factory = new ServiceFactory(){
    13.     public Service getService(){
    14.         return new Implemention1();
    15.     }
    16. };
    17.   }
    18.   public class Implemention2 implements Service {
    19. public void method1(){
    20.     System.out.println(“in Implemention2 method method1()”);
    21. }
    23. public static ServiceFactory factory = new ServiceFactory(){
    24.     public Service getService(){
    25.         return new Implemention2();
    26.     }
    27. };
    29.   }
    30.   public class Test {
    31. public static void main(String []args){
    32.     service(Implemention1.factory);
    33.     service(Implemention2.factory);
    35.     ServiceFactory factory1 = Implemention1.factory;
    36.     Service service1 = factory1.getService();
    37.     service1.method1();
    39.     ServiceFactory factory2 = Implemention1.factory;
    40.     Service service2 = factory2.getService();
    41.     service2.method1();
    42. }
    43.   }

    在Implemention1和2中匿名内部类用在字段初始化地方。
    这样定义的工厂方法，代码上看起来是不是优雅一些？

    7、嵌套类
    static的内部类就叫做嵌套类
    前面提到了很多次，嵌套类是个例外
    使用嵌套类时有两点需要注意：
    a、创建嵌套类对象时，不需要外围类
    b、在嵌套类中，不能像普通内部类一样访问外围类的非static成员

    Java代码  

    1.   public class StaticClass {
    2. private int num;
    3. private static int sum = 2;
    4. private static class StaticInnerClass{
    5.     public int getNum(){
    6.     //只能访问sum，不能访问num
    7.                return sum;
    8.     }
    9. }
    10.   }
    11.   public class Test {
    12. public static void main(String [] args){
    13.                //可以直接通过new来创建嵌套类对象
    14.     StaticClass.StaticInnerClass inner = new StaticClass.StaticInnerClass();
    15.     inner.getNum();
    16. }
    17.   }

    另外，嵌套类还有特殊之处，就是嵌套类中可以有static方法，static字段与嵌套类，而普通内部类中不能有这些。

    8、内部类标识符
    我们知道每个类会产生一个.class文件，文件名即为类名
    同样，内部类也会产生这么一个.class文件，但是它的名称却不是内部类的类名，而是有着严格的限制：外围类的名字，加上$,再加上内部类名字。
    前面说到得定义在方法内的内部类，不是在调用方法时生成，而是与外围类一同编译，就可以通过查看.class文件的方式来证明。

    9、为何要内部类？
    a、内部类提供了某种进入外围类的窗户。
    b、也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外围类是否已经继承了某个接口。
    因此，内部类使多重继承的解决方案变得更加完整。
    在项目中，需要多重继承，如果是两个接口，那么好办，接口支持多重继承。
    如果是两个类呢？这时只有使用内部类了。

    Java代码  

    1.    public interface One {
    2. public void inOne();
    3.    }
    4.    public interface Two {
    5. public void inTwo();
    6.    }
    7.    //两个接口，用普通类就可实现多重继承
    8.    public class CommonClass implements One,Two {
    9. public void inOne(){
    10.     System.out.println(“CommonClass inOne() method”);
    11. }
    13. public void inTwo(){
    14.     System.out.println(“CommonClass inTwo() method”);
    15. }
    16.    }
    17.    public abstract class Three {
    18. public abstract void inThree();
    19.    }
    20.    public abstract class Four {
    21. public abstract void inFour();
    22.    }
    23.    //两个抽象类，使用普通类无法实现多重继承
    25.    //使用内部类可以实现
    26.    public class Contents extends Three {
    27. public void inThree(){
    28.     System.out.println(“In Contents inThress() method”);
    29. }
    31. public class InnerFour extends Four{
    32.     public void inFour(){
    33.         System.out.println(“In Contents”);
    34.     }
    36. }
    37.    }

    另外，还有好多地方可以使用内部类。读过hibernate源代码的同学，应该可以发现，里面有好多内部类。
    最常见的内部类，应该是Map.Entry了，可以看看源代码~

    总结：
    内部类的特性大致就是上述了，特性很直观，了解了之后，使用也很简单。
    但是，何时使用我说的并不是很明确，因为本人知识有限，使用内部类也不是很多。项目中很少用，好像就是ActiveMQ那里用了一些。
    不过，相信大家在了解了内部类的特性之后，再随着时间的推移，慢慢积累经验，应该会做出自己的判断，会在何时使用内部类，怎样应用了

南京怀宇通用评卷系统操作日志软件工程师火速招聘 待遇永远超过承诺