认识内部类

旧城等待， 2022-05-16 06:11 33阅读 0赞

## **问题引出** ##

public class Outter{
    
        private int a = 0;
    
        private class Inner{
            public int getA(){
                return ++a;
            }
        }
    
        private Inner getInner(){
            return new Inner();
        }
    
        public static void main(String[] args){
            Outter out = new Outter();
            System.out.println(out.getInner().getA());
        }
    }

打印出的结果是： 1   
Outter是外围类，Inner是内部类。打印的结果为1，则说明i确实被++了，而加1操作是在Inner中的，为什么内部类能够访问外围类的成员变量？

## **内部类和外部类的联系** ##

上面的例子说明，内部类拥有对外部类的所有成员的访问权，这是因为，当某个外部类对象创建一个内部类对象时，此内部类对象必然会秘密得获取到一个指向那个外部类对象的引用。因此，当你在内部类访问外部类的成员时，就是用这个引用来访问的。

但外部类想要访问内部类的成员，则必须要先获得内部类的对象才能访问。

## **静态内部类** ##

如果你不需要内部类跟外部类有联系，则可以使用静态内部类，将内部类声明为static。区别在于，普通的内部类会自动获得对外部类对象的引用，而静态内部类则不需要外部类对象的引用。

public class Outter{
    
        private static class Inner{
            private String a = "inner";
        }
    
        public static void main(String[] args){
            Outter.Inner inner = new Outter.Inner();
            System.out.println(inner.a);
        }
    }

## **创建内部类对象** ##

创建静态内部类对象： 外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()   
创建普通内部类对象： 外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()

可见，创建普通内部类对象使用使用外部类对象来使用.new语法，而静态内部类的对象创建则不需要外部类对象。

## **匿名内部类** ##

匿名内部类是内部中最常使用的，例如在Android的点击事件中，匿名内部类的使用：

button.setOnClickListener(new OnClickListener(){
    
        @Override
        public void onClick(){
    
        }
    
    });

使用匿名内部类的原因是因为普通内部类冗长并且难以维护，而匿名内部类维护则容易多了，当我们不需要内部类的对象时，我们应该优先使用匿名内部类。   
但是匿名内部类比较受限，因为它只能实现接口或者继承类，两者不可兼得，并且即使实现接口，也只能实现一个接口。因此，匿名内部类多用于事件的回调。   
关于两者的选择，完全要看代码的需求！

注意事项：   
匿名内部类中使用的外部类的成员一定要声明为final。

### 值得思考的例子 ###

interface Ball{
        void play();
    }
    
    public class Test{
    
        private Ball getBall(){
            return new Ball(){
    
                @Override
                public void play() {
    
                }
    
            };
        }
    }

问题：接口不是不能new的吗？   
这里使用的是匿名内部类，new Ball\{\}，创建一个实现了Ball接口的类，但是因为我们并不需要该类的实例，因此我们无需再写一个类去实现接口，然后在new这个类。这就是匿名内部类的方便之处，在这里它省略了临时定义类实现接口的开销。

## **为什么需要内部类** ##

我认为内部类存在最重要的意义在于，**它完善了Java的多重继承机制**   
没有内部类的情况下，我么使用多重继承实现只能通过接口，但是接口的局限在于，实现接口，就必须实现它所有的方法，这就是什么在能使用接口和类的情况下，优先使用类。   
假如一个人，他想要拥有吃饭和睡觉两种能力，但只能通过继承类来获得这种能力，只能通过内部类。   
如这个例子：

abstract class Sleep{
        abstract void sleep();
    }
    
    abstract class Eat{
        abstract void eat();
    }
    
    class Person extends Eat{
    
        public void showMyAbility(){
            MySleep sleep = new MySleep();
            this.eat();
            sleep.sleep();
        }
    
        @Override
        void eat() {
            System.out.println("I has ability of ate");
        }
    
        class MySleep extends Sleep{
    
            @Override
            void sleep() {
                System.out.println("I has ability of slpet");
            }
    
        }
    
    }
    
    public class TestInterface{
        public static void main(String[] args){
             Person person = new Person();
             person.showMyAbility();
        }
    }

发掘到一个写得挺好的关于内部类的文章，里面关于匿名内部类变量为什么是final的进行了一番探讨，值得收藏：   
[Java内部类详解][Java]

[Java]: http://www.cnblogs.com/dolphin0520/p/3811445.html